/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_depthwise_conv2d_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/depthwise_conv2d/window_stride_fixture.h"

#include <array>
#include <vector>

using DataTypeList = sycldnn::types::KernelDataTypes;
using Backends = sycldnn::types::DefaultBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<DataTypeList, Backends>::type;
using GTestTypePairs = sycldnn::types::ToGTestTypes<SNNTypePairs>::type;

template <typename Pair>
using ForwardWindow1Stride1 =
    sycldnn::depthwise_conv2d::WindowStrideTest<Pair, 1, 1>;
TYPED_TEST_SUITE(ForwardWindow1Stride1, GTestTypePairs);
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 2., 4., 3., 6., 4., 8.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 2., 4., 3., 6., 4., 8.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  2., 4., 6.,  8.,
                                         3., 6., 9., 12., 4., 8., 12., 16.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  2., 4., 6.,  8.,
                                         3., 6., 9., 12., 4., 8., 12., 16.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 4., 3., 8., 5., 12., 7., 16.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 4., 3., 8., 5., 12., 7., 16.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  6.,  8.,  3., 6.,  12., 16.,
                                         5., 10., 18., 24., 7., 14., 24., 32.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  6.,  8.,  3., 6.,  12., 16.,
                                         5., 10., 18., 24., 7., 14., 24., 32.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  10., 12., 14., 16.,
                                         3., 6.,  9.,  12., 20., 24., 28., 32.,
                                         5., 10., 15., 20., 30., 36., 42., 48.,
                                         7., 14., 21., 28., 40., 48., 56., 64.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  10., 12., 14., 16.,
                                         3., 6.,  9.,  12., 20., 24., 28., 32.,
                                         5., 10., 15., 20., 30., 36., 42., 48.,
                                         7., 14., 21., 28., 40., 48., 56., 64.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 4.,  9.,  16., 5.,  12., 21., 32.,
                                         9., 20., 33., 48., 13., 28., 45., 64.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 4.,  9.,  16., 5.,  12., 21., 32.,
                                         9., 20., 33., 48., 13., 28., 45., 64.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,  8.,  15., 18., 28., 32., 5.,   10., 18.,
      24., 35., 42., 56., 64., 9.,  18., 30., 40.,  55., 66.,
      84., 96., 13., 26., 42., 56., 75., 90., 112., 128.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,  8.,  15., 18., 28., 32., 5.,   10., 18.,
      24., 35., 42., 56., 64., 9.,  18., 30., 40.,  55., 66.,
      84., 96., 13., 26., 42., 56., 75., 90., 112., 128.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   10.,  12.,  14.,  16.,  27.,  30.,  33.,  36., 52.,
      56., 60., 64.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,  63., 70.,
      77., 84., 104., 112., 120., 128., 9.,   18.,  27.,  36.,  50.,  60., 70.,
      80., 99., 110., 121., 132., 156., 168., 180., 192., 13.,  26.,  39., 52.,
      70., 84., 98.,  112., 135., 150., 165., 180., 208., 224., 240., 256.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   10.,  12.,  14.,  16.,  27.,  30.,  33.,  36., 52.,
      56., 60., 64.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,  63., 70.,
      77., 84., 104., 112., 120., 128., 9.,   18.,  27.,  36.,  50.,  60., 70.,
      80., 99., 110., 121., 132., 156., 168., 180., 192., 13.,  26.,  39., 52.,
      70., 84., 98.,  112., 135., 150., 165., 180., 208., 224., 240., 256.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 2., 4.,  3., 6.,
                                         4., 8., 5., 10., 6., 12.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 2., 4.,  3., 6.,
                                         4., 8., 5., 10., 6., 12.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  2., 4.,  6.,  8.,
                                         3., 6.,  9.,  12., 4., 8.,  12., 16.,
                                         5., 10., 15., 20., 6., 12., 18., 24.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  2., 4.,  6.,  8.,
                                         3., 6.,  9.,  12., 4., 8.,  12., 16.,
                                         5., 10., 15., 20., 6., 12., 18., 24.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 4.,  3., 8.,  5.,  12.,
                                         7., 16., 9., 20., 11., 24.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 4.,  3., 8.,  5.,  12.,
                                         7., 16., 9., 20., 11., 24.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  6.,  8.,  3.,  6.,  12., 16.,
                                         5., 10., 18., 24., 7.,  14., 24., 32.,
                                         9., 18., 30., 40., 11., 22., 36., 48.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  6.,  8.,  3.,  6.,  12., 16.,
                                         5., 10., 18., 24., 7.,  14., 24., 32.,
                                         9., 18., 30., 40., 11., 22., 36., 48.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  10., 12., 14., 16., 3.,  6.,  9.,  12.,
      20., 24., 28., 32., 5.,  10., 15., 20., 30., 36., 42., 48.,
      7.,  14., 21., 28., 40., 48., 56., 64., 9.,  18., 27., 36.,
      50., 60., 70., 80., 11., 22., 33., 44., 60., 72., 84., 96.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  10., 12., 14., 16., 3.,  6.,  9.,  12.,
      20., 24., 28., 32., 5.,  10., 15., 20., 30., 36., 42., 48.,
      7.,  14., 21., 28., 40., 48., 56., 64., 9.,  18., 27., 36.,
      50., 60., 70., 80., 11., 22., 33., 44., 60., 72., 84., 96.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  9.,  16., 5.,  12., 21., 32., 9.,  20., 33., 48.,
      13., 28., 45., 64., 17., 36., 57., 80., 21., 44., 69., 96.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  9.,  16., 5.,  12., 21., 32., 9.,  20., 33., 48.,
      13., 28., 45., 64., 17., 36., 57., 80., 21., 44., 69., 96.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,   6.,   8.,   15., 18., 28.,  32.,  5.,   10.,  18.,  24.,
      35., 42.,  56.,  64.,  9.,  18., 30.,  40.,  55.,  66.,  84.,  96.,
      13., 26.,  42.,  56.,  75., 90., 112., 128., 17.,  34.,  54.,  72.,
      95., 114., 140., 160., 21., 42., 66.,  88.,  115., 138., 168., 192.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,   6.,   8.,   15., 18., 28.,  32.,  5.,   10.,  18.,  24.,
      35., 42.,  56.,  64.,  9.,  18., 30.,  40.,  55.,  66.,  84.,  96.,
      13., 26.,  42.,  56.,  75., 90., 112., 128., 17.,  34.,  54.,  72.,
      95., 114., 140., 160., 21., 42., 66.,  88.,  115., 138., 168., 192.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  27.,  30.,  33.,  36.,
      52.,  56.,  60.,  64.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      63.,  70.,  77.,  84.,  104., 112., 120., 128., 9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  99.,  110., 121., 132., 156., 168., 180., 192.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 135., 150., 165., 180.,
      208., 224., 240., 256., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      171., 190., 209., 228., 260., 280., 300., 320., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 207., 230., 253., 276., 312., 336., 360., 384.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  27.,  30.,  33.,  36.,
      52.,  56.,  60.,  64.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      63.,  70.,  77.,  84.,  104., 112., 120., 128., 9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  99.,  110., 121., 132., 156., 168., 180., 192.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 135., 150., 165., 180.,
      208., 224., 240., 256., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      171., 190., 209., 228., 260., 280., 300., 320., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 207., 230., 253., 276., 312., 336., 360., 384.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2., 4.,  3., 6.,  4., 8.,
                                         5., 10., 6., 12., 7., 14., 8., 16.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2., 4.,  3., 6.,  4., 8.,
                                         5., 10., 6., 12., 7., 14., 8., 16.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  2., 4.,  6.,  8.,
                                         3., 6.,  9.,  12., 4., 8.,  12., 16.,
                                         5., 10., 15., 20., 6., 12., 18., 24.,
                                         7., 14., 21., 28., 8., 16., 24., 32.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  2., 4.,  6.,  8.,
                                         3., 6.,  9.,  12., 4., 8.,  12., 16.,
                                         5., 10., 15., 20., 6., 12., 18., 24.,
                                         7., 14., 21., 28., 8., 16., 24., 32.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 4.,  3.,  8.,  5.,  12., 7.,  16.,
                                         9., 20., 11., 24., 13., 28., 15., 32.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 4.,  3.,  8.,  5.,  12., 7.,  16.,
                                         9., 20., 11., 24., 13., 28., 15., 32.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,  8.,  3.,  6.,  12., 16., 5.,  10., 18.,
      24., 7.,  14., 24., 32., 9.,  18., 30., 40., 11., 22.,
      36., 48., 13., 26., 42., 56., 15., 30., 48., 64.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,  8.,  3.,  6.,  12., 16., 5.,  10., 18.,
      24., 7.,  14., 24., 32., 9.,  18., 30., 40., 11., 22.,
      36., 48., 13., 26., 42., 56., 15., 30., 48., 64.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,   10., 12., 14., 16., 3.,  6.,  9.,   12., 20.,
      24., 28., 32., 5.,   10., 15., 20., 30., 36., 42., 48.,  7.,  14.,
      21., 28., 40., 48.,  56., 64., 9.,  18., 27., 36., 50.,  60., 70.,
      80., 11., 22., 33.,  44., 60., 72., 84., 96., 13., 26.,  39., 52.,
      70., 84., 98., 112., 15., 30., 45., 60., 80., 96., 112., 128.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,   10., 12., 14., 16., 3.,  6.,  9.,   12., 20.,
      24., 28., 32., 5.,   10., 15., 20., 30., 36., 42., 48.,  7.,  14.,
      21., 28., 40., 48.,  56., 64., 9.,  18., 27., 36., 50.,  60., 70.,
      80., 11., 22., 33.,  44., 60., 72., 84., 96., 13., 26.,  39., 52.,
      70., 84., 98., 112., 15., 30., 45., 60., 80., 96., 112., 128.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  9.,  16., 5.,  12.,  21., 32., 9.,  20., 33.,
      48., 13., 28., 45., 64., 17.,  36., 57., 80., 21., 44.,
      69., 96., 25., 52., 81., 112., 29., 60., 93., 128.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  9.,  16., 5.,  12.,  21., 32., 9.,  20., 33.,
      48., 13., 28., 45., 64., 17.,  36., 57., 80., 21., 44.,
      69., 96., 25., 52., 81., 112., 29., 60., 93., 128.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   6.,   8.,   15.,  18.,  28.,  32.,  5.,   10.,  18.,
      24.,  35.,  42.,  56.,  64.,  9.,   18.,  30.,  40.,  55.,  66.,
      84.,  96.,  13.,  26.,  42.,  56.,  75.,  90.,  112., 128., 17.,
      34.,  54.,  72.,  95.,  114., 140., 160., 21.,  42.,  66.,  88.,
      115., 138., 168., 192., 25.,  50.,  78.,  104., 135., 162., 196.,
      224., 29.,  58.,  90.,  120., 155., 186., 224., 256.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   6.,   8.,   15.,  18.,  28.,  32.,  5.,   10.,  18.,
      24.,  35.,  42.,  56.,  64.,  9.,   18.,  30.,  40.,  55.,  66.,
      84.,  96.,  13.,  26.,  42.,  56.,  75.,  90.,  112., 128., 17.,
      34.,  54.,  72.,  95.,  114., 140., 160., 21.,  42.,  66.,  88.,
      115., 138., 168., 192., 25.,  50.,  78.,  104., 135., 162., 196.,
      224., 29.,  58.,  90.,  120., 155., 186., 224., 256.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  27.,  30.,  33.,  36.,
      52.,  56.,  60.,  64.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      63.,  70.,  77.,  84.,  104., 112., 120., 128., 9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  99.,  110., 121., 132., 156., 168., 180., 192.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 135., 150., 165., 180.,
      208., 224., 240., 256., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      171., 190., 209., 228., 260., 280., 300., 320., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 207., 230., 253., 276., 312., 336., 360., 384.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 243., 270., 297., 324.,
      364., 392., 420., 448., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      279., 310., 341., 372., 416., 448., 480., 512.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  27.,  30.,  33.,  36.,
      52.,  56.,  60.,  64.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      63.,  70.,  77.,  84.,  104., 112., 120., 128., 9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  99.,  110., 121., 132., 156., 168., 180., 192.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 135., 150., 165., 180.,
      208., 224., 240., 256., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      171., 190., 209., 228., 260., 280., 300., 320., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 207., 230., 253., 276., 312., 336., 360., 384.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 243., 270., 297., 324.,
      364., 392., 420., 448., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      279., 310., 341., 372., 416., 448., 480., 512.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 2., 4.,  3., 6.,
                                         4., 8., 5., 10., 6., 12.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 2., 4.,  3., 6.,
                                         4., 8., 5., 10., 6., 12.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  2., 4.,  6.,  8.,
                                         3., 6.,  9.,  12., 4., 8.,  12., 16.,
                                         5., 10., 15., 20., 6., 12., 18., 24.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  2., 4.,  6.,  8.,
                                         3., 6.,  9.,  12., 4., 8.,  12., 16.,
                                         5., 10., 15., 20., 6., 12., 18., 24.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 4.,  3., 8.,  5.,  12.,
                                         7., 16., 9., 20., 11., 24.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 4.,  3., 8.,  5.,  12.,
                                         7., 16., 9., 20., 11., 24.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  6.,  8.,  3.,  6.,  12., 16.,
                                         5., 10., 18., 24., 7.,  14., 24., 32.,
                                         9., 18., 30., 40., 11., 22., 36., 48.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  6.,  8.,  3.,  6.,  12., 16.,
                                         5., 10., 18., 24., 7.,  14., 24., 32.,
                                         9., 18., 30., 40., 11., 22., 36., 48.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  10., 12., 14., 16., 3.,  6.,  9.,  12.,
      20., 24., 28., 32., 5.,  10., 15., 20., 30., 36., 42., 48.,
      7.,  14., 21., 28., 40., 48., 56., 64., 9.,  18., 27., 36.,
      50., 60., 70., 80., 11., 22., 33., 44., 60., 72., 84., 96.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  10., 12., 14., 16., 3.,  6.,  9.,  12.,
      20., 24., 28., 32., 5.,  10., 15., 20., 30., 36., 42., 48.,
      7.,  14., 21., 28., 40., 48., 56., 64., 9.,  18., 27., 36.,
      50., 60., 70., 80., 11., 22., 33., 44., 60., 72., 84., 96.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  9.,  16., 5.,  12., 21., 32., 9.,  20., 33., 48.,
      13., 28., 45., 64., 17., 36., 57., 80., 21., 44., 69., 96.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  9.,  16., 5.,  12., 21., 32., 9.,  20., 33., 48.,
      13., 28., 45., 64., 17., 36., 57., 80., 21., 44., 69., 96.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,   6.,   8.,   15., 18., 28.,  32.,  5.,   10.,  18.,  24.,
      35., 42.,  56.,  64.,  9.,  18., 30.,  40.,  55.,  66.,  84.,  96.,
      13., 26.,  42.,  56.,  75., 90., 112., 128., 17.,  34.,  54.,  72.,
      95., 114., 140., 160., 21., 42., 66.,  88.,  115., 138., 168., 192.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,   6.,   8.,   15., 18., 28.,  32.,  5.,   10.,  18.,  24.,
      35., 42.,  56.,  64.,  9.,  18., 30.,  40.,  55.,  66.,  84.,  96.,
      13., 26.,  42.,  56.,  75., 90., 112., 128., 17.,  34.,  54.,  72.,
      95., 114., 140., 160., 21., 42., 66.,  88.,  115., 138., 168., 192.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  27.,  30.,  33.,  36.,
      52.,  56.,  60.,  64.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      63.,  70.,  77.,  84.,  104., 112., 120., 128., 9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  99.,  110., 121., 132., 156., 168., 180., 192.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 135., 150., 165., 180.,
      208., 224., 240., 256., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      171., 190., 209., 228., 260., 280., 300., 320., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 207., 230., 253., 276., 312., 336., 360., 384.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  27.,  30.,  33.,  36.,
      52.,  56.,  60.,  64.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      63.,  70.,  77.,  84.,  104., 112., 120., 128., 9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  99.,  110., 121., 132., 156., 168., 180., 192.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 135., 150., 165., 180.,
      208., 224., 240., 256., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      171., 190., 209., 228., 260., 280., 300., 320., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 207., 230., 253., 276., 312., 336., 360., 384.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8., 9.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8., 9.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2., 4.,  3., 6.,
                                         4., 8.,  5., 10., 6., 12.,
                                         7., 14., 8., 16., 9., 18.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2., 4.,  3., 6.,
                                         4., 8.,  5., 10., 6., 12.,
                                         7., 14., 8., 16., 9., 18.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1., 2.,  3.,  4.,  2., 4.,  6.,  8.,  3., 6.,  9.,  12.,
      4., 8.,  12., 16., 5., 10., 15., 20., 6., 12., 18., 24.,
      7., 14., 21., 28., 8., 16., 24., 32., 9., 18., 27., 36.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1., 2.,  3.,  4.,  2., 4.,  6.,  8.,  3., 6.,  9.,  12.,
      4., 8.,  12., 16., 5., 10., 15., 20., 6., 12., 18., 24.,
      7., 14., 21., 28., 8., 16., 24., 32., 9., 18., 27., 36.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  4.,  3.,  8.,  5.,  12.,
                                         7.,  16., 9.,  20., 11., 24.,
                                         13., 28., 15., 32., 17., 36.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  4.,  3.,  8.,  5.,  12.,
                                         7.,  16., 9.,  20., 11., 24.,
                                         13., 28., 15., 32., 17., 36.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,  8.,  3.,  6.,  12., 16., 5.,  10., 18., 24.,
      7.,  14., 24., 32., 9.,  18., 30., 40., 11., 22., 36., 48.,
      13., 26., 42., 56., 15., 30., 48., 64., 17., 34., 54., 72.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,  8.,  3.,  6.,  12., 16., 5.,  10., 18., 24.,
      7.,  14., 24., 32., 9.,  18., 30., 40., 11., 22., 36., 48.,
      13., 26., 42., 56., 15., 30., 48., 64., 17., 34., 54., 72.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   10., 12., 14., 16.,  3.,  6.,   9.,   12.,
      20., 24., 28.,  32.,  5.,  10., 15., 20.,  30., 36.,  42.,  48.,
      7.,  14., 21.,  28.,  40., 48., 56., 64.,  9.,  18.,  27.,  36.,
      50., 60., 70.,  80.,  11., 22., 33., 44.,  60., 72.,  84.,  96.,
      13., 26., 39.,  52.,  70., 84., 98., 112., 15., 30.,  45.,  60.,
      80., 96., 112., 128., 17., 34., 51., 68.,  90., 108., 126., 144.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   10., 12., 14., 16.,  3.,  6.,   9.,   12.,
      20., 24., 28.,  32.,  5.,  10., 15., 20.,  30., 36.,  42.,  48.,
      7.,  14., 21.,  28.,  40., 48., 56., 64.,  9.,  18.,  27.,  36.,
      50., 60., 70.,  80.,  11., 22., 33., 44.,  60., 72.,  84.,  96.,
      13., 26., 39.,  52.,  70., 84., 98., 112., 15., 30.,  45.,  60.,
      80., 96., 112., 128., 17., 34., 51., 68.,  90., 108., 126., 144.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  9.,  16.,  5.,  12., 21., 32.,  9.,  20., 33.,  48.,
      13., 28., 45., 64.,  17., 36., 57., 80.,  21., 44., 69.,  96.,
      25., 52., 81., 112., 29., 60., 93., 128., 33., 68., 105., 144.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  9.,  16.,  5.,  12., 21., 32.,  9.,  20., 33.,  48.,
      13., 28., 45., 64.,  17., 36., 57., 80.,  21., 44., 69.,  96.,
      25., 52., 81., 112., 29., 60., 93., 128., 33., 68., 105., 144.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   6.,   8.,   15.,  18.,  28.,  32.,  5.,   10.,  18.,  24.,
      35.,  42.,  56.,  64.,  9.,   18.,  30.,  40.,  55.,  66.,  84.,  96.,
      13.,  26.,  42.,  56.,  75.,  90.,  112., 128., 17.,  34.,  54.,  72.,
      95.,  114., 140., 160., 21.,  42.,  66.,  88.,  115., 138., 168., 192.,
      25.,  50.,  78.,  104., 135., 162., 196., 224., 29.,  58.,  90.,  120.,
      155., 186., 224., 256., 33.,  66.,  102., 136., 175., 210., 252., 288.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   6.,   8.,   15.,  18.,  28.,  32.,  5.,   10.,  18.,  24.,
      35.,  42.,  56.,  64.,  9.,   18.,  30.,  40.,  55.,  66.,  84.,  96.,
      13.,  26.,  42.,  56.,  75.,  90.,  112., 128., 17.,  34.,  54.,  72.,
      95.,  114., 140., 160., 21.,  42.,  66.,  88.,  115., 138., 168., 192.,
      25.,  50.,  78.,  104., 135., 162., 196., 224., 29.,  58.,  90.,  120.,
      155., 186., 224., 256., 33.,  66.,  102., 136., 175., 210., 252., 288.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  27.,  30.,  33.,  36.,
      52.,  56.,  60.,  64.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      63.,  70.,  77.,  84.,  104., 112., 120., 128., 9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  99.,  110., 121., 132., 156., 168., 180., 192.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 135., 150., 165., 180.,
      208., 224., 240., 256., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      171., 190., 209., 228., 260., 280., 300., 320., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 207., 230., 253., 276., 312., 336., 360., 384.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 243., 270., 297., 324.,
      364., 392., 420., 448., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      279., 310., 341., 372., 416., 448., 480., 512., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 315., 350., 385., 420., 468., 504., 540., 576.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  27.,  30.,  33.,  36.,
      52.,  56.,  60.,  64.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      63.,  70.,  77.,  84.,  104., 112., 120., 128., 9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  99.,  110., 121., 132., 156., 168., 180., 192.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 135., 150., 165., 180.,
      208., 224., 240., 256., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      171., 190., 209., 228., 260., 280., 300., 320., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 207., 230., 253., 276., 312., 336., 360., 384.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 243., 270., 297., 324.,
      364., 392., 420., 448., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      279., 310., 341., 372., 416., 448., 480., 512., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 315., 350., 385., 420., 468., 504., 540., 576.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2.,  4.,  3.,  6.,  4.,  8.,
                                         5., 10., 6.,  12., 7.,  14., 8.,  16.,
                                         9., 18., 10., 20., 11., 22., 12., 24.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2.,  4.,  3.,  6.,  4.,  8.,
                                         5., 10., 6.,  12., 7.,  14., 8.,  16.,
                                         9., 18., 10., 20., 11., 22., 12., 24.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12.,
      4.,  8.,  12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24.,
      7.,  14., 21., 28., 8.,  16., 24., 32., 9.,  18., 27., 36.,
      10., 20., 30., 40., 11., 22., 33., 44., 12., 24., 36., 48.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12.,
      4.,  8.,  12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24.,
      7.,  14., 21., 28., 8.,  16., 24., 32., 9.,  18., 27., 36.,
      10., 20., 30., 40., 11., 22., 33., 44., 12., 24., 36., 48.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  3.,  8.,  5.,  12., 7.,  16., 9.,  20., 11., 24.,
      13., 28., 15., 32., 17., 36., 19., 40., 21., 44., 23., 48.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  3.,  8.,  5.,  12., 7.,  16., 9.,  20., 11., 24.,
      13., 28., 15., 32., 17., 36., 19., 40., 21., 44., 23., 48.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,  8.,  3.,  6.,  12., 16., 5.,  10., 18., 24.,
      7.,  14., 24., 32., 9.,  18., 30., 40., 11., 22., 36., 48.,
      13., 26., 42., 56., 15., 30., 48., 64., 17., 34., 54., 72.,
      19., 38., 60., 80., 21., 42., 66., 88., 23., 46., 72., 96.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,  8.,  3.,  6.,  12., 16., 5.,  10., 18., 24.,
      7.,  14., 24., 32., 9.,  18., 30., 40., 11., 22., 36., 48.,
      13., 26., 42., 56., 15., 30., 48., 64., 17., 34., 54., 72.,
      19., 38., 60., 80., 21., 42., 66., 88., 23., 46., 72., 96.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  3.,   6.,   9.,   12.,
      20.,  24.,  28.,  32.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      7.,   14.,  21.,  28.,  40.,  48.,  56.,  64.,  9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  11.,  22.,  33.,  44.,  60.,  72.,  84.,  96.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 15.,  30.,  45.,  60.,
      80.,  96.,  112., 128., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      19.,  38.,  57.,  76.,  100., 120., 140., 160., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 23.,  46.,  69.,  92.,  120., 144., 168., 192.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  3.,   6.,   9.,   12.,
      20.,  24.,  28.,  32.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      7.,   14.,  21.,  28.,  40.,  48.,  56.,  64.,  9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  11.,  22.,  33.,  44.,  60.,  72.,  84.,  96.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 15.,  30.,  45.,  60.,
      80.,  96.,  112., 128., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      19.,  38.,  57.,  76.,  100., 120., 140., 160., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 23.,  46.,  69.,  92.,  120., 144., 168., 192.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  9.,   16.,  5.,  12., 21.,  32.,  9.,  20., 33.,  48.,
      13., 28., 45.,  64.,  17., 36., 57.,  80.,  21., 44., 69.,  96.,
      25., 52., 81.,  112., 29., 60., 93.,  128., 33., 68., 105., 144.,
      37., 76., 117., 160., 41., 84., 129., 176., 45., 92., 141., 192.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  9.,   16.,  5.,  12., 21.,  32.,  9.,  20., 33.,  48.,
      13., 28., 45.,  64.,  17., 36., 57.,  80.,  21., 44., 69.,  96.,
      25., 52., 81.,  112., 29., 60., 93.,  128., 33., 68., 105., 144.,
      37., 76., 117., 160., 41., 84., 129., 176., 45., 92., 141., 192.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   6.,   8.,   15.,  18.,  28.,  32.,  5.,   10.,  18.,  24.,
      35.,  42.,  56.,  64.,  9.,   18.,  30.,  40.,  55.,  66.,  84.,  96.,
      13.,  26.,  42.,  56.,  75.,  90.,  112., 128., 17.,  34.,  54.,  72.,
      95.,  114., 140., 160., 21.,  42.,  66.,  88.,  115., 138., 168., 192.,
      25.,  50.,  78.,  104., 135., 162., 196., 224., 29.,  58.,  90.,  120.,
      155., 186., 224., 256., 33.,  66.,  102., 136., 175., 210., 252., 288.,
      37.,  74.,  114., 152., 195., 234., 280., 320., 41.,  82.,  126., 168.,
      215., 258., 308., 352., 45.,  90.,  138., 184., 235., 282., 336., 384.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   6.,   8.,   15.,  18.,  28.,  32.,  5.,   10.,  18.,  24.,
      35.,  42.,  56.,  64.,  9.,   18.,  30.,  40.,  55.,  66.,  84.,  96.,
      13.,  26.,  42.,  56.,  75.,  90.,  112., 128., 17.,  34.,  54.,  72.,
      95.,  114., 140., 160., 21.,  42.,  66.,  88.,  115., 138., 168., 192.,
      25.,  50.,  78.,  104., 135., 162., 196., 224., 29.,  58.,  90.,  120.,
      155., 186., 224., 256., 33.,  66.,  102., 136., 175., 210., 252., 288.,
      37.,  74.,  114., 152., 195., 234., 280., 320., 41.,  82.,  126., 168.,
      215., 258., 308., 352., 45.,  90.,  138., 184., 235., 282., 336., 384.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  27.,  30.,  33.,  36.,
      52.,  56.,  60.,  64.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      63.,  70.,  77.,  84.,  104., 112., 120., 128., 9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  99.,  110., 121., 132., 156., 168., 180., 192.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 135., 150., 165., 180.,
      208., 224., 240., 256., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      171., 190., 209., 228., 260., 280., 300., 320., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 207., 230., 253., 276., 312., 336., 360., 384.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 243., 270., 297., 324.,
      364., 392., 420., 448., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      279., 310., 341., 372., 416., 448., 480., 512., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 315., 350., 385., 420., 468., 504., 540., 576.,
      37.,  74.,  111., 148., 190., 228., 266., 304., 351., 390., 429., 468.,
      520., 560., 600., 640., 41.,  82.,  123., 164., 210., 252., 294., 336.,
      387., 430., 473., 516., 572., 616., 660., 704., 45.,  90.,  135., 180.,
      230., 276., 322., 368., 423., 470., 517., 564., 624., 672., 720., 768.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  27.,  30.,  33.,  36.,
      52.,  56.,  60.,  64.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      63.,  70.,  77.,  84.,  104., 112., 120., 128., 9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  99.,  110., 121., 132., 156., 168., 180., 192.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 135., 150., 165., 180.,
      208., 224., 240., 256., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      171., 190., 209., 228., 260., 280., 300., 320., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 207., 230., 253., 276., 312., 336., 360., 384.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 243., 270., 297., 324.,
      364., 392., 420., 448., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      279., 310., 341., 372., 416., 448., 480., 512., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 315., 350., 385., 420., 468., 504., 540., 576.,
      37.,  74.,  111., 148., 190., 228., 266., 304., 351., 390., 429., 468.,
      520., 560., 600., 640., 41.,  82.,  123., 164., 210., 252., 294., 336.,
      387., 430., 473., 516., 572., 616., 660., 704., 45.,  90.,  135., 180.,
      230., 276., 322., 368., 423., 470., 517., 564., 624., 672., 720., 768.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2., 4.,  3., 6.,  4., 8.,
                                         5., 10., 6., 12., 7., 14., 8., 16.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2., 4.,  3., 6.,  4., 8.,
                                         5., 10., 6., 12., 7., 14., 8., 16.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  2., 4.,  6.,  8.,
                                         3., 6.,  9.,  12., 4., 8.,  12., 16.,
                                         5., 10., 15., 20., 6., 12., 18., 24.,
                                         7., 14., 21., 28., 8., 16., 24., 32.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  2., 4.,  6.,  8.,
                                         3., 6.,  9.,  12., 4., 8.,  12., 16.,
                                         5., 10., 15., 20., 6., 12., 18., 24.,
                                         7., 14., 21., 28., 8., 16., 24., 32.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 4.,  3.,  8.,  5.,  12., 7.,  16.,
                                         9., 20., 11., 24., 13., 28., 15., 32.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 4.,  3.,  8.,  5.,  12., 7.,  16.,
                                         9., 20., 11., 24., 13., 28., 15., 32.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,  8.,  3.,  6.,  12., 16., 5.,  10., 18.,
      24., 7.,  14., 24., 32., 9.,  18., 30., 40., 11., 22.,
      36., 48., 13., 26., 42., 56., 15., 30., 48., 64.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,  8.,  3.,  6.,  12., 16., 5.,  10., 18.,
      24., 7.,  14., 24., 32., 9.,  18., 30., 40., 11., 22.,
      36., 48., 13., 26., 42., 56., 15., 30., 48., 64.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,   10., 12., 14., 16., 3.,  6.,  9.,   12., 20.,
      24., 28., 32., 5.,   10., 15., 20., 30., 36., 42., 48.,  7.,  14.,
      21., 28., 40., 48.,  56., 64., 9.,  18., 27., 36., 50.,  60., 70.,
      80., 11., 22., 33.,  44., 60., 72., 84., 96., 13., 26.,  39., 52.,
      70., 84., 98., 112., 15., 30., 45., 60., 80., 96., 112., 128.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,   10., 12., 14., 16., 3.,  6.,  9.,   12., 20.,
      24., 28., 32., 5.,   10., 15., 20., 30., 36., 42., 48.,  7.,  14.,
      21., 28., 40., 48.,  56., 64., 9.,  18., 27., 36., 50.,  60., 70.,
      80., 11., 22., 33.,  44., 60., 72., 84., 96., 13., 26.,  39., 52.,
      70., 84., 98., 112., 15., 30., 45., 60., 80., 96., 112., 128.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  9.,  16., 5.,  12.,  21., 32., 9.,  20., 33.,
      48., 13., 28., 45., 64., 17.,  36., 57., 80., 21., 44.,
      69., 96., 25., 52., 81., 112., 29., 60., 93., 128.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  9.,  16., 5.,  12.,  21., 32., 9.,  20., 33.,
      48., 13., 28., 45., 64., 17.,  36., 57., 80., 21., 44.,
      69., 96., 25., 52., 81., 112., 29., 60., 93., 128.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   6.,   8.,   15.,  18.,  28.,  32.,  5.,   10.,  18.,
      24.,  35.,  42.,  56.,  64.,  9.,   18.,  30.,  40.,  55.,  66.,
      84.,  96.,  13.,  26.,  42.,  56.,  75.,  90.,  112., 128., 17.,
      34.,  54.,  72.,  95.,  114., 140., 160., 21.,  42.,  66.,  88.,
      115., 138., 168., 192., 25.,  50.,  78.,  104., 135., 162., 196.,
      224., 29.,  58.,  90.,  120., 155., 186., 224., 256.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   6.,   8.,   15.,  18.,  28.,  32.,  5.,   10.,  18.,
      24.,  35.,  42.,  56.,  64.,  9.,   18.,  30.,  40.,  55.,  66.,
      84.,  96.,  13.,  26.,  42.,  56.,  75.,  90.,  112., 128., 17.,
      34.,  54.,  72.,  95.,  114., 140., 160., 21.,  42.,  66.,  88.,
      115., 138., 168., 192., 25.,  50.,  78.,  104., 135., 162., 196.,
      224., 29.,  58.,  90.,  120., 155., 186., 224., 256.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  27.,  30.,  33.,  36.,
      52.,  56.,  60.,  64.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      63.,  70.,  77.,  84.,  104., 112., 120., 128., 9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  99.,  110., 121., 132., 156., 168., 180., 192.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 135., 150., 165., 180.,
      208., 224., 240., 256., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      171., 190., 209., 228., 260., 280., 300., 320., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 207., 230., 253., 276., 312., 336., 360., 384.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 243., 270., 297., 324.,
      364., 392., 420., 448., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      279., 310., 341., 372., 416., 448., 480., 512.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  27.,  30.,  33.,  36.,
      52.,  56.,  60.,  64.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      63.,  70.,  77.,  84.,  104., 112., 120., 128., 9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  99.,  110., 121., 132., 156., 168., 180., 192.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 135., 150., 165., 180.,
      208., 224., 240., 256., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      171., 190., 209., 228., 260., 280., 300., 320., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 207., 230., 253., 276., 312., 336., 360., 384.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 243., 270., 297., 324.,
      364., 392., 420., 448., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      279., 310., 341., 372., 416., 448., 480., 512.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2.,  4.,  3.,  6.,  4.,  8.,
                                         5., 10., 6.,  12., 7.,  14., 8.,  16.,
                                         9., 18., 10., 20., 11., 22., 12., 24.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2.,  4.,  3.,  6.,  4.,  8.,
                                         5., 10., 6.,  12., 7.,  14., 8.,  16.,
                                         9., 18., 10., 20., 11., 22., 12., 24.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12.,
      4.,  8.,  12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24.,
      7.,  14., 21., 28., 8.,  16., 24., 32., 9.,  18., 27., 36.,
      10., 20., 30., 40., 11., 22., 33., 44., 12., 24., 36., 48.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12.,
      4.,  8.,  12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24.,
      7.,  14., 21., 28., 8.,  16., 24., 32., 9.,  18., 27., 36.,
      10., 20., 30., 40., 11., 22., 33., 44., 12., 24., 36., 48.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  3.,  8.,  5.,  12., 7.,  16., 9.,  20., 11., 24.,
      13., 28., 15., 32., 17., 36., 19., 40., 21., 44., 23., 48.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  3.,  8.,  5.,  12., 7.,  16., 9.,  20., 11., 24.,
      13., 28., 15., 32., 17., 36., 19., 40., 21., 44., 23., 48.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,  8.,  3.,  6.,  12., 16., 5.,  10., 18., 24.,
      7.,  14., 24., 32., 9.,  18., 30., 40., 11., 22., 36., 48.,
      13., 26., 42., 56., 15., 30., 48., 64., 17., 34., 54., 72.,
      19., 38., 60., 80., 21., 42., 66., 88., 23., 46., 72., 96.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,  8.,  3.,  6.,  12., 16., 5.,  10., 18., 24.,
      7.,  14., 24., 32., 9.,  18., 30., 40., 11., 22., 36., 48.,
      13., 26., 42., 56., 15., 30., 48., 64., 17., 34., 54., 72.,
      19., 38., 60., 80., 21., 42., 66., 88., 23., 46., 72., 96.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  3.,   6.,   9.,   12.,
      20.,  24.,  28.,  32.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      7.,   14.,  21.,  28.,  40.,  48.,  56.,  64.,  9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  11.,  22.,  33.,  44.,  60.,  72.,  84.,  96.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 15.,  30.,  45.,  60.,
      80.,  96.,  112., 128., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      19.,  38.,  57.,  76.,  100., 120., 140., 160., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 23.,  46.,  69.,  92.,  120., 144., 168., 192.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  3.,   6.,   9.,   12.,
      20.,  24.,  28.,  32.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      7.,   14.,  21.,  28.,  40.,  48.,  56.,  64.,  9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  11.,  22.,  33.,  44.,  60.,  72.,  84.,  96.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 15.,  30.,  45.,  60.,
      80.,  96.,  112., 128., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      19.,  38.,  57.,  76.,  100., 120., 140., 160., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 23.,  46.,  69.,  92.,  120., 144., 168., 192.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  9.,   16.,  5.,  12., 21.,  32.,  9.,  20., 33.,  48.,
      13., 28., 45.,  64.,  17., 36., 57.,  80.,  21., 44., 69.,  96.,
      25., 52., 81.,  112., 29., 60., 93.,  128., 33., 68., 105., 144.,
      37., 76., 117., 160., 41., 84., 129., 176., 45., 92., 141., 192.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  9.,   16.,  5.,  12., 21.,  32.,  9.,  20., 33.,  48.,
      13., 28., 45.,  64.,  17., 36., 57.,  80.,  21., 44., 69.,  96.,
      25., 52., 81.,  112., 29., 60., 93.,  128., 33., 68., 105., 144.,
      37., 76., 117., 160., 41., 84., 129., 176., 45., 92., 141., 192.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   6.,   8.,   15.,  18.,  28.,  32.,  5.,   10.,  18.,  24.,
      35.,  42.,  56.,  64.,  9.,   18.,  30.,  40.,  55.,  66.,  84.,  96.,
      13.,  26.,  42.,  56.,  75.,  90.,  112., 128., 17.,  34.,  54.,  72.,
      95.,  114., 140., 160., 21.,  42.,  66.,  88.,  115., 138., 168., 192.,
      25.,  50.,  78.,  104., 135., 162., 196., 224., 29.,  58.,  90.,  120.,
      155., 186., 224., 256., 33.,  66.,  102., 136., 175., 210., 252., 288.,
      37.,  74.,  114., 152., 195., 234., 280., 320., 41.,  82.,  126., 168.,
      215., 258., 308., 352., 45.,  90.,  138., 184., 235., 282., 336., 384.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   6.,   8.,   15.,  18.,  28.,  32.,  5.,   10.,  18.,  24.,
      35.,  42.,  56.,  64.,  9.,   18.,  30.,  40.,  55.,  66.,  84.,  96.,
      13.,  26.,  42.,  56.,  75.,  90.,  112., 128., 17.,  34.,  54.,  72.,
      95.,  114., 140., 160., 21.,  42.,  66.,  88.,  115., 138., 168., 192.,
      25.,  50.,  78.,  104., 135., 162., 196., 224., 29.,  58.,  90.,  120.,
      155., 186., 224., 256., 33.,  66.,  102., 136., 175., 210., 252., 288.,
      37.,  74.,  114., 152., 195., 234., 280., 320., 41.,  82.,  126., 168.,
      215., 258., 308., 352., 45.,  90.,  138., 184., 235., 282., 336., 384.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  27.,  30.,  33.,  36.,
      52.,  56.,  60.,  64.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      63.,  70.,  77.,  84.,  104., 112., 120., 128., 9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  99.,  110., 121., 132., 156., 168., 180., 192.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 135., 150., 165., 180.,
      208., 224., 240., 256., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      171., 190., 209., 228., 260., 280., 300., 320., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 207., 230., 253., 276., 312., 336., 360., 384.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 243., 270., 297., 324.,
      364., 392., 420., 448., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      279., 310., 341., 372., 416., 448., 480., 512., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 315., 350., 385., 420., 468., 504., 540., 576.,
      37.,  74.,  111., 148., 190., 228., 266., 304., 351., 390., 429., 468.,
      520., 560., 600., 640., 41.,  82.,  123., 164., 210., 252., 294., 336.,
      387., 430., 473., 516., 572., 616., 660., 704., 45.,  90.,  135., 180.,
      230., 276., 322., 368., 423., 470., 517., 564., 624., 672., 720., 768.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  27.,  30.,  33.,  36.,
      52.,  56.,  60.,  64.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      63.,  70.,  77.,  84.,  104., 112., 120., 128., 9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  99.,  110., 121., 132., 156., 168., 180., 192.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 135., 150., 165., 180.,
      208., 224., 240., 256., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      171., 190., 209., 228., 260., 280., 300., 320., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 207., 230., 253., 276., 312., 336., 360., 384.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 243., 270., 297., 324.,
      364., 392., 420., 448., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      279., 310., 341., 372., 416., 448., 480., 512., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 315., 350., 385., 420., 468., 504., 540., 576.,
      37.,  74.,  111., 148., 190., 228., 266., 304., 351., 390., 429., 468.,
      520., 560., 600., 640., 41.,  82.,  123., 164., 210., 252., 294., 336.,
      387., 430., 473., 516., 572., 616., 660., 704., 45.,  90.,  135., 180.,
      230., 276., 322., 368., 423., 470., 517., 564., 624., 672., 720., 768.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  5.,  6.,  7.,  8.,
                                         9., 10., 11., 12., 13., 14., 15., 16.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  5.,  6.,  7.,  8.,
                                         9., 10., 11., 12., 13., 14., 15., 16.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,
      12., 7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22.,
      12., 24., 13., 26., 14., 28., 15., 30., 16., 32.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,
      12., 7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22.,
      12., 24., 13., 26., 14., 28., 15., 30., 16., 32.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,
      8.,  12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14.,
      21., 28., 8.,  16., 24., 32., 9.,  18., 27., 36., 10., 20., 30.,
      40., 11., 22., 33., 44., 12., 24., 36., 48., 13., 26., 39., 52.,
      14., 28., 42., 56., 15., 30., 45., 60., 16., 32., 48., 64.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,
      8.,  12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14.,
      21., 28., 8.,  16., 24., 32., 9.,  18., 27., 36., 10., 20., 30.,
      40., 11., 22., 33., 44., 12., 24., 36., 48., 13., 26., 39., 52.,
      14., 28., 42., 56., 15., 30., 45., 60., 16., 32., 48., 64.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  3.,  8.,  5.,  12., 7.,  16., 9.,  20., 11.,
      24., 13., 28., 15., 32., 17., 36., 19., 40., 21., 44.,
      23., 48., 25., 52., 27., 56., 29., 60., 31., 64.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  3.,  8.,  5.,  12., 7.,  16., 9.,  20., 11.,
      24., 13., 28., 15., 32., 17., 36., 19., 40., 21., 44.,
      23., 48., 25., 52., 27., 56., 29., 60., 31., 64.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,  8.,   3.,  6.,  12., 16.,  5.,  10., 18., 24., 7.,
      14., 24., 32., 9.,   18., 30., 40., 11.,  22., 36., 48., 13., 26.,
      42., 56., 15., 30.,  48., 64., 17., 34.,  54., 72., 19., 38., 60.,
      80., 21., 42., 66.,  88., 23., 46., 72.,  96., 25., 50., 78., 104.,
      27., 54., 84., 112., 29., 58., 90., 120., 31., 62., 96., 128.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,  8.,   3.,  6.,  12., 16.,  5.,  10., 18., 24., 7.,
      14., 24., 32., 9.,   18., 30., 40., 11.,  22., 36., 48., 13., 26.,
      42., 56., 15., 30.,  48., 64., 17., 34.,  54., 72., 19., 38., 60.,
      80., 21., 42., 66.,  88., 23., 46., 72.,  96., 25., 50., 78., 104.,
      27., 54., 84., 112., 29., 58., 90., 120., 31., 62., 96., 128.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  3.,   6.,   9.,   12.,
      20.,  24.,  28.,  32.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      7.,   14.,  21.,  28.,  40.,  48.,  56.,  64.,  9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  11.,  22.,  33.,  44.,  60.,  72.,  84.,  96.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 15.,  30.,  45.,  60.,
      80.,  96.,  112., 128., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      19.,  38.,  57.,  76.,  100., 120., 140., 160., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 23.,  46.,  69.,  92.,  120., 144., 168., 192.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 27.,  54.,  81.,  108.,
      140., 168., 196., 224., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      31.,  62.,  93.,  124., 160., 192., 224., 256.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  3.,   6.,   9.,   12.,
      20.,  24.,  28.,  32.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      7.,   14.,  21.,  28.,  40.,  48.,  56.,  64.,  9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  11.,  22.,  33.,  44.,  60.,  72.,  84.,  96.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 15.,  30.,  45.,  60.,
      80.,  96.,  112., 128., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      19.,  38.,  57.,  76.,  100., 120., 140., 160., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 23.,  46.,  69.,  92.,  120., 144., 168., 192.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 27.,  54.,  81.,  108.,
      140., 168., 196., 224., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      31.,  62.,  93.,  124., 160., 192., 224., 256.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   9.,   16.,  5.,   12.,  21.,  32.,  9.,  20.,  33.,
      48.,  13.,  28.,  45.,  64.,  17.,  36.,  57.,  80., 21.,  44.,
      69.,  96.,  25.,  52.,  81.,  112., 29.,  60.,  93., 128., 33.,
      68.,  105., 144., 37.,  76.,  117., 160., 41.,  84., 129., 176.,
      45.,  92.,  141., 192., 49.,  100., 153., 208., 53., 108., 165.,
      224., 57.,  116., 177., 240., 61.,  124., 189., 256.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   9.,   16.,  5.,   12.,  21.,  32.,  9.,  20.,  33.,
      48.,  13.,  28.,  45.,  64.,  17.,  36.,  57.,  80., 21.,  44.,
      69.,  96.,  25.,  52.,  81.,  112., 29.,  60.,  93., 128., 33.,
      68.,  105., 144., 37.,  76.,  117., 160., 41.,  84., 129., 176.,
      45.,  92.,  141., 192., 49.,  100., 153., 208., 53., 108., 165.,
      224., 57.,  116., 177., 240., 61.,  124., 189., 256.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   6.,   8.,   15.,  18.,  28.,  32.,  5.,   10.,  18.,  24.,
      35.,  42.,  56.,  64.,  9.,   18.,  30.,  40.,  55.,  66.,  84.,  96.,
      13.,  26.,  42.,  56.,  75.,  90.,  112., 128., 17.,  34.,  54.,  72.,
      95.,  114., 140., 160., 21.,  42.,  66.,  88.,  115., 138., 168., 192.,
      25.,  50.,  78.,  104., 135., 162., 196., 224., 29.,  58.,  90.,  120.,
      155., 186., 224., 256., 33.,  66.,  102., 136., 175., 210., 252., 288.,
      37.,  74.,  114., 152., 195., 234., 280., 320., 41.,  82.,  126., 168.,
      215., 258., 308., 352., 45.,  90.,  138., 184., 235., 282., 336., 384.,
      49.,  98.,  150., 200., 255., 306., 364., 416., 53.,  106., 162., 216.,
      275., 330., 392., 448., 57.,  114., 174., 232., 295., 354., 420., 480.,
      61.,  122., 186., 248., 315., 378., 448., 512.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   6.,   8.,   15.,  18.,  28.,  32.,  5.,   10.,  18.,  24.,
      35.,  42.,  56.,  64.,  9.,   18.,  30.,  40.,  55.,  66.,  84.,  96.,
      13.,  26.,  42.,  56.,  75.,  90.,  112., 128., 17.,  34.,  54.,  72.,
      95.,  114., 140., 160., 21.,  42.,  66.,  88.,  115., 138., 168., 192.,
      25.,  50.,  78.,  104., 135., 162., 196., 224., 29.,  58.,  90.,  120.,
      155., 186., 224., 256., 33.,  66.,  102., 136., 175., 210., 252., 288.,
      37.,  74.,  114., 152., 195., 234., 280., 320., 41.,  82.,  126., 168.,
      215., 258., 308., 352., 45.,  90.,  138., 184., 235., 282., 336., 384.,
      49.,  98.,  150., 200., 255., 306., 364., 416., 53.,  106., 162., 216.,
      275., 330., 392., 448., 57.,  114., 174., 232., 295., 354., 420., 480.,
      61.,  122., 186., 248., 315., 378., 448., 512.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  27.,  30.,  33.,  36.,
      52.,  56.,  60.,  64.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      63.,  70.,  77.,  84.,  104., 112., 120., 128., 9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  99.,  110., 121., 132., 156., 168., 180., 192.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 135., 150., 165., 180.,
      208., 224., 240., 256., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      171., 190., 209., 228., 260., 280., 300., 320., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 207., 230., 253., 276., 312., 336., 360., 384.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 243., 270., 297., 324.,
      364., 392., 420., 448., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      279., 310., 341., 372., 416., 448., 480., 512., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 315., 350., 385., 420., 468., 504., 540., 576.,
      37.,  74.,  111., 148., 190., 228., 266., 304., 351., 390., 429., 468.,
      520., 560., 600., 640., 41.,  82.,  123., 164., 210., 252., 294., 336.,
      387., 430., 473., 516., 572., 616., 660., 704., 45.,  90.,  135., 180.,
      230., 276., 322., 368., 423., 470., 517., 564., 624., 672., 720., 768.,
      49.,  98.,  147., 196., 250., 300., 350., 400., 459., 510., 561., 612.,
      676., 728., 780., 832., 53.,  106., 159., 212., 270., 324., 378., 432.,
      495., 550., 605., 660., 728., 784., 840., 896., 57.,  114., 171., 228.,
      290., 348., 406., 464., 531., 590., 649., 708., 780., 840., 900., 960.,
      61.,  122., 183., 244., 310., 372., 434., 496., 567., 630., 693., 756.,
      832., 896., 960., 1024.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  27.,  30.,  33.,  36.,
      52.,  56.,  60.,  64.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      63.,  70.,  77.,  84.,  104., 112., 120., 128., 9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  99.,  110., 121., 132., 156., 168., 180., 192.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 135., 150., 165., 180.,
      208., 224., 240., 256., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      171., 190., 209., 228., 260., 280., 300., 320., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 207., 230., 253., 276., 312., 336., 360., 384.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 243., 270., 297., 324.,
      364., 392., 420., 448., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      279., 310., 341., 372., 416., 448., 480., 512., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 315., 350., 385., 420., 468., 504., 540., 576.,
      37.,  74.,  111., 148., 190., 228., 266., 304., 351., 390., 429., 468.,
      520., 560., 600., 640., 41.,  82.,  123., 164., 210., 252., 294., 336.,
      387., 430., 473., 516., 572., 616., 660., 704., 45.,  90.,  135., 180.,
      230., 276., 322., 368., 423., 470., 517., 564., 624., 672., 720., 768.,
      49.,  98.,  147., 196., 250., 300., 350., 400., 459., 510., 561., 612.,
      676., 728., 780., 832., 53.,  106., 159., 212., 270., 324., 378., 432.,
      495., 550., 605., 660., 728., 784., 840., 896., 57.,  114., 171., 228.,
      290., 348., 406., 464., 531., 590., 649., 708., 780., 840., 900., 960.,
      61.,  122., 183., 244., 310., 372., 434., 496., 567., 630., 693., 756.,
      832., 896., 960., 1024.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2.,  4.,  3.,  6.,  4.,  8.,
                                         5., 10., 6.,  12., 7.,  14., 8.,  16.,
                                         9., 18., 10., 20., 11., 22., 12., 24.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2.,  4.,  3.,  6.,  4.,  8.,
                                         5., 10., 6.,  12., 7.,  14., 8.,  16.,
                                         9., 18., 10., 20., 11., 22., 12., 24.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12.,
      4.,  8.,  12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24.,
      7.,  14., 21., 28., 8.,  16., 24., 32., 9.,  18., 27., 36.,
      10., 20., 30., 40., 11., 22., 33., 44., 12., 24., 36., 48.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12.,
      4.,  8.,  12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24.,
      7.,  14., 21., 28., 8.,  16., 24., 32., 9.,  18., 27., 36.,
      10., 20., 30., 40., 11., 22., 33., 44., 12., 24., 36., 48.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  3.,  8.,  5.,  12., 7.,  16., 9.,  20., 11., 24.,
      13., 28., 15., 32., 17., 36., 19., 40., 21., 44., 23., 48.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  3.,  8.,  5.,  12., 7.,  16., 9.,  20., 11., 24.,
      13., 28., 15., 32., 17., 36., 19., 40., 21., 44., 23., 48.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,  8.,  3.,  6.,  12., 16., 5.,  10., 18., 24.,
      7.,  14., 24., 32., 9.,  18., 30., 40., 11., 22., 36., 48.,
      13., 26., 42., 56., 15., 30., 48., 64., 17., 34., 54., 72.,
      19., 38., 60., 80., 21., 42., 66., 88., 23., 46., 72., 96.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,  8.,  3.,  6.,  12., 16., 5.,  10., 18., 24.,
      7.,  14., 24., 32., 9.,  18., 30., 40., 11., 22., 36., 48.,
      13., 26., 42., 56., 15., 30., 48., 64., 17., 34., 54., 72.,
      19., 38., 60., 80., 21., 42., 66., 88., 23., 46., 72., 96.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  3.,   6.,   9.,   12.,
      20.,  24.,  28.,  32.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      7.,   14.,  21.,  28.,  40.,  48.,  56.,  64.,  9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  11.,  22.,  33.,  44.,  60.,  72.,  84.,  96.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 15.,  30.,  45.,  60.,
      80.,  96.,  112., 128., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      19.,  38.,  57.,  76.,  100., 120., 140., 160., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 23.,  46.,  69.,  92.,  120., 144., 168., 192.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  3.,   6.,   9.,   12.,
      20.,  24.,  28.,  32.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      7.,   14.,  21.,  28.,  40.,  48.,  56.,  64.,  9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  11.,  22.,  33.,  44.,  60.,  72.,  84.,  96.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 15.,  30.,  45.,  60.,
      80.,  96.,  112., 128., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      19.,  38.,  57.,  76.,  100., 120., 140., 160., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 23.,  46.,  69.,  92.,  120., 144., 168., 192.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  9.,   16.,  5.,  12., 21.,  32.,  9.,  20., 33.,  48.,
      13., 28., 45.,  64.,  17., 36., 57.,  80.,  21., 44., 69.,  96.,
      25., 52., 81.,  112., 29., 60., 93.,  128., 33., 68., 105., 144.,
      37., 76., 117., 160., 41., 84., 129., 176., 45., 92., 141., 192.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  9.,   16.,  5.,  12., 21.,  32.,  9.,  20., 33.,  48.,
      13., 28., 45.,  64.,  17., 36., 57.,  80.,  21., 44., 69.,  96.,
      25., 52., 81.,  112., 29., 60., 93.,  128., 33., 68., 105., 144.,
      37., 76., 117., 160., 41., 84., 129., 176., 45., 92., 141., 192.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   6.,   8.,   15.,  18.,  28.,  32.,  5.,   10.,  18.,  24.,
      35.,  42.,  56.,  64.,  9.,   18.,  30.,  40.,  55.,  66.,  84.,  96.,
      13.,  26.,  42.,  56.,  75.,  90.,  112., 128., 17.,  34.,  54.,  72.,
      95.,  114., 140., 160., 21.,  42.,  66.,  88.,  115., 138., 168., 192.,
      25.,  50.,  78.,  104., 135., 162., 196., 224., 29.,  58.,  90.,  120.,
      155., 186., 224., 256., 33.,  66.,  102., 136., 175., 210., 252., 288.,
      37.,  74.,  114., 152., 195., 234., 280., 320., 41.,  82.,  126., 168.,
      215., 258., 308., 352., 45.,  90.,  138., 184., 235., 282., 336., 384.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   6.,   8.,   15.,  18.,  28.,  32.,  5.,   10.,  18.,  24.,
      35.,  42.,  56.,  64.,  9.,   18.,  30.,  40.,  55.,  66.,  84.,  96.,
      13.,  26.,  42.,  56.,  75.,  90.,  112., 128., 17.,  34.,  54.,  72.,
      95.,  114., 140., 160., 21.,  42.,  66.,  88.,  115., 138., 168., 192.,
      25.,  50.,  78.,  104., 135., 162., 196., 224., 29.,  58.,  90.,  120.,
      155., 186., 224., 256., 33.,  66.,  102., 136., 175., 210., 252., 288.,
      37.,  74.,  114., 152., 195., 234., 280., 320., 41.,  82.,  126., 168.,
      215., 258., 308., 352., 45.,  90.,  138., 184., 235., 282., 336., 384.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  27.,  30.,  33.,  36.,
      52.,  56.,  60.,  64.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      63.,  70.,  77.,  84.,  104., 112., 120., 128., 9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  99.,  110., 121., 132., 156., 168., 180., 192.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 135., 150., 165., 180.,
      208., 224., 240., 256., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      171., 190., 209., 228., 260., 280., 300., 320., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 207., 230., 253., 276., 312., 336., 360., 384.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 243., 270., 297., 324.,
      364., 392., 420., 448., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      279., 310., 341., 372., 416., 448., 480., 512., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 315., 350., 385., 420., 468., 504., 540., 576.,
      37.,  74.,  111., 148., 190., 228., 266., 304., 351., 390., 429., 468.,
      520., 560., 600., 640., 41.,  82.,  123., 164., 210., 252., 294., 336.,
      387., 430., 473., 516., 572., 616., 660., 704., 45.,  90.,  135., 180.,
      230., 276., 322., 368., 423., 470., 517., 564., 624., 672., 720., 768.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  27.,  30.,  33.,  36.,
      52.,  56.,  60.,  64.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      63.,  70.,  77.,  84.,  104., 112., 120., 128., 9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  99.,  110., 121., 132., 156., 168., 180., 192.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 135., 150., 165., 180.,
      208., 224., 240., 256., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      171., 190., 209., 228., 260., 280., 300., 320., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 207., 230., 253., 276., 312., 336., 360., 384.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 243., 270., 297., 324.,
      364., 392., 420., 448., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      279., 310., 341., 372., 416., 448., 480., 512., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 315., 350., 385., 420., 468., 504., 540., 576.,
      37.,  74.,  111., 148., 190., 228., 266., 304., 351., 390., 429., 468.,
      520., 560., 600., 640., 41.,  82.,  123., 164., 210., 252., 294., 336.,
      387., 430., 473., 516., 572., 616., 660., 704., 45.,  90.,  135., 180.,
      230., 276., 322., 368., 423., 470., 517., 564., 624., 672., 720., 768.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  4.,  5.,  6.,
                                         7.,  8.,  9.,  10., 11., 12.,
                                         13., 14., 15., 16., 17., 18.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  4.,  5.,  6.,
                                         7.,  8.,  9.,  10., 11., 12.,
                                         13., 14., 15., 16., 17., 18.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12.,
      7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24.,
      13., 26., 14., 28., 15., 30., 16., 32., 17., 34., 18., 36.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12.,
      7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24.,
      13., 26., 14., 28., 15., 30., 16., 32., 17., 34., 18., 36.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,  12.,
      16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14., 21., 28., 8.,  16.,
      24., 32., 9.,  18., 27., 36., 10., 20., 30., 40., 11., 22., 33., 44., 12.,
      24., 36., 48., 13., 26., 39., 52., 14., 28., 42., 56., 15., 30., 45., 60.,
      16., 32., 48., 64., 17., 34., 51., 68., 18., 36., 54., 72.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,  12.,
      16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14., 21., 28., 8.,  16.,
      24., 32., 9.,  18., 27., 36., 10., 20., 30., 40., 11., 22., 33., 44., 12.,
      24., 36., 48., 13., 26., 39., 52., 14., 28., 42., 56., 15., 30., 45., 60.,
      16., 32., 48., 64., 17., 34., 51., 68., 18., 36., 54., 72.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  3.,  8.,  5.,  12., 7.,  16., 9.,  20., 11., 24.,
      13., 28., 15., 32., 17., 36., 19., 40., 21., 44., 23., 48.,
      25., 52., 27., 56., 29., 60., 31., 64., 33., 68., 35., 72.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  3.,  8.,  5.,  12., 7.,  16., 9.,  20., 11., 24.,
      13., 28., 15., 32., 17., 36., 19., 40., 21., 44., 23., 48.,
      25., 52., 27., 56., 29., 60., 31., 64., 33., 68., 35., 72.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,  8.,   3.,  6.,  12.,  16.,  5.,  10., 18.,  24.,
      7.,  14., 24., 32.,  9.,  18., 30.,  40.,  11., 22., 36.,  48.,
      13., 26., 42., 56.,  15., 30., 48.,  64.,  17., 34., 54.,  72.,
      19., 38., 60., 80.,  21., 42., 66.,  88.,  23., 46., 72.,  96.,
      25., 50., 78., 104., 27., 54., 84.,  112., 29., 58., 90.,  120.,
      31., 62., 96., 128., 33., 66., 102., 136., 35., 70., 108., 144.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,  8.,   3.,  6.,  12.,  16.,  5.,  10., 18.,  24.,
      7.,  14., 24., 32.,  9.,  18., 30.,  40.,  11., 22., 36.,  48.,
      13., 26., 42., 56.,  15., 30., 48.,  64.,  17., 34., 54.,  72.,
      19., 38., 60., 80.,  21., 42., 66.,  88.,  23., 46., 72.,  96.,
      25., 50., 78., 104., 27., 54., 84.,  112., 29., 58., 90.,  120.,
      31., 62., 96., 128., 33., 66., 102., 136., 35., 70., 108., 144.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  3.,   6.,   9.,   12.,
      20.,  24.,  28.,  32.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      7.,   14.,  21.,  28.,  40.,  48.,  56.,  64.,  9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  11.,  22.,  33.,  44.,  60.,  72.,  84.,  96.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 15.,  30.,  45.,  60.,
      80.,  96.,  112., 128., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      19.,  38.,  57.,  76.,  100., 120., 140., 160., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 23.,  46.,  69.,  92.,  120., 144., 168., 192.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 27.,  54.,  81.,  108.,
      140., 168., 196., 224., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      31.,  62.,  93.,  124., 160., 192., 224., 256., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 35.,  70.,  105., 140., 180., 216., 252., 288.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  3.,   6.,   9.,   12.,
      20.,  24.,  28.,  32.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      7.,   14.,  21.,  28.,  40.,  48.,  56.,  64.,  9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  11.,  22.,  33.,  44.,  60.,  72.,  84.,  96.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 15.,  30.,  45.,  60.,
      80.,  96.,  112., 128., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      19.,  38.,  57.,  76.,  100., 120., 140., 160., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 23.,  46.,  69.,  92.,  120., 144., 168., 192.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 27.,  54.,  81.,  108.,
      140., 168., 196., 224., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      31.,  62.,  93.,  124., 160., 192., 224., 256., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 35.,  70.,  105., 140., 180., 216., 252., 288.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,   9.,   16.,  5.,  12.,  21.,  32.,  9.,  20.,  33.,  48.,
      13., 28.,  45.,  64.,  17., 36.,  57.,  80.,  21., 44.,  69.,  96.,
      25., 52.,  81.,  112., 29., 60.,  93.,  128., 33., 68.,  105., 144.,
      37., 76.,  117., 160., 41., 84.,  129., 176., 45., 92.,  141., 192.,
      49., 100., 153., 208., 53., 108., 165., 224., 57., 116., 177., 240.,
      61., 124., 189., 256., 65., 132., 201., 272., 69., 140., 213., 288.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,   9.,   16.,  5.,  12.,  21.,  32.,  9.,  20.,  33.,  48.,
      13., 28.,  45.,  64.,  17., 36.,  57.,  80.,  21., 44.,  69.,  96.,
      25., 52.,  81.,  112., 29., 60.,  93.,  128., 33., 68.,  105., 144.,
      37., 76.,  117., 160., 41., 84.,  129., 176., 45., 92.,  141., 192.,
      49., 100., 153., 208., 53., 108., 165., 224., 57., 116., 177., 240.,
      61., 124., 189., 256., 65., 132., 201., 272., 69., 140., 213., 288.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   6.,   8.,   15.,  18.,  28.,  32.,  5.,   10.,  18.,  24.,
      35.,  42.,  56.,  64.,  9.,   18.,  30.,  40.,  55.,  66.,  84.,  96.,
      13.,  26.,  42.,  56.,  75.,  90.,  112., 128., 17.,  34.,  54.,  72.,
      95.,  114., 140., 160., 21.,  42.,  66.,  88.,  115., 138., 168., 192.,
      25.,  50.,  78.,  104., 135., 162., 196., 224., 29.,  58.,  90.,  120.,
      155., 186., 224., 256., 33.,  66.,  102., 136., 175., 210., 252., 288.,
      37.,  74.,  114., 152., 195., 234., 280., 320., 41.,  82.,  126., 168.,
      215., 258., 308., 352., 45.,  90.,  138., 184., 235., 282., 336., 384.,
      49.,  98.,  150., 200., 255., 306., 364., 416., 53.,  106., 162., 216.,
      275., 330., 392., 448., 57.,  114., 174., 232., 295., 354., 420., 480.,
      61.,  122., 186., 248., 315., 378., 448., 512., 65.,  130., 198., 264.,
      335., 402., 476., 544., 69.,  138., 210., 280., 355., 426., 504., 576.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   6.,   8.,   15.,  18.,  28.,  32.,  5.,   10.,  18.,  24.,
      35.,  42.,  56.,  64.,  9.,   18.,  30.,  40.,  55.,  66.,  84.,  96.,
      13.,  26.,  42.,  56.,  75.,  90.,  112., 128., 17.,  34.,  54.,  72.,
      95.,  114., 140., 160., 21.,  42.,  66.,  88.,  115., 138., 168., 192.,
      25.,  50.,  78.,  104., 135., 162., 196., 224., 29.,  58.,  90.,  120.,
      155., 186., 224., 256., 33.,  66.,  102., 136., 175., 210., 252., 288.,
      37.,  74.,  114., 152., 195., 234., 280., 320., 41.,  82.,  126., 168.,
      215., 258., 308., 352., 45.,  90.,  138., 184., 235., 282., 336., 384.,
      49.,  98.,  150., 200., 255., 306., 364., 416., 53.,  106., 162., 216.,
      275., 330., 392., 448., 57.,  114., 174., 232., 295., 354., 420., 480.,
      61.,  122., 186., 248., 315., 378., 448., 512., 65.,  130., 198., 264.,
      335., 402., 476., 544., 69.,  138., 210., 280., 355., 426., 504., 576.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,   3.,    4.,   10.,  12.,  14.,   16.,   27.,  30.,  33.,
      36.,   52.,  56.,   60.,  64.,  5.,   10.,   15.,   20.,  30.,  36.,
      42.,   48.,  63.,   70.,  77.,  84.,  104.,  112.,  120., 128., 9.,
      18.,   27.,  36.,   50.,  60.,  70.,  80.,   99.,   110., 121., 132.,
      156.,  168., 180.,  192., 13.,  26.,  39.,   52.,   70.,  84.,  98.,
      112.,  135., 150.,  165., 180., 208., 224.,  240.,  256., 17.,  34.,
      51.,   68.,  90.,   108., 126., 144., 171.,  190.,  209., 228., 260.,
      280.,  300., 320.,  21.,  42.,  63.,  84.,   110.,  132., 154., 176.,
      207.,  230., 253.,  276., 312., 336., 360.,  384.,  25.,  50.,  75.,
      100.,  130., 156.,  182., 208., 243., 270.,  297.,  324., 364., 392.,
      420.,  448., 29.,   58.,  87.,  116., 150.,  180.,  210., 240., 279.,
      310.,  341., 372.,  416., 448., 480., 512.,  33.,   66.,  99.,  132.,
      170.,  204., 238.,  272., 315., 350., 385.,  420.,  468., 504., 540.,
      576.,  37.,  74.,   111., 148., 190., 228.,  266.,  304., 351., 390.,
      429.,  468., 520.,  560., 600., 640., 41.,   82.,   123., 164., 210.,
      252.,  294., 336.,  387., 430., 473., 516.,  572.,  616., 660., 704.,
      45.,   90.,  135.,  180., 230., 276., 322.,  368.,  423., 470., 517.,
      564.,  624., 672.,  720., 768., 49.,  98.,   147.,  196., 250., 300.,
      350.,  400., 459.,  510., 561., 612., 676.,  728.,  780., 832., 53.,
      106.,  159., 212.,  270., 324., 378., 432.,  495.,  550., 605., 660.,
      728.,  784., 840.,  896., 57.,  114., 171.,  228.,  290., 348., 406.,
      464.,  531., 590.,  649., 708., 780., 840.,  900.,  960., 61.,  122.,
      183.,  244., 310.,  372., 434., 496., 567.,  630.,  693., 756., 832.,
      896.,  960., 1024., 65.,  130., 195., 260.,  330.,  396., 462., 528.,
      603.,  670., 737.,  804., 884., 952., 1020., 1088., 69.,  138., 207.,
      276.,  350., 420.,  490., 560., 639., 710.,  781.,  852., 936., 1008.,
      1080., 1152.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,   3.,    4.,   10.,  12.,  14.,   16.,   27.,  30.,  33.,
      36.,   52.,  56.,   60.,  64.,  5.,   10.,   15.,   20.,  30.,  36.,
      42.,   48.,  63.,   70.,  77.,  84.,  104.,  112.,  120., 128., 9.,
      18.,   27.,  36.,   50.,  60.,  70.,  80.,   99.,   110., 121., 132.,
      156.,  168., 180.,  192., 13.,  26.,  39.,   52.,   70.,  84.,  98.,
      112.,  135., 150.,  165., 180., 208., 224.,  240.,  256., 17.,  34.,
      51.,   68.,  90.,   108., 126., 144., 171.,  190.,  209., 228., 260.,
      280.,  300., 320.,  21.,  42.,  63.,  84.,   110.,  132., 154., 176.,
      207.,  230., 253.,  276., 312., 336., 360.,  384.,  25.,  50.,  75.,
      100.,  130., 156.,  182., 208., 243., 270.,  297.,  324., 364., 392.,
      420.,  448., 29.,   58.,  87.,  116., 150.,  180.,  210., 240., 279.,
      310.,  341., 372.,  416., 448., 480., 512.,  33.,   66.,  99.,  132.,
      170.,  204., 238.,  272., 315., 350., 385.,  420.,  468., 504., 540.,
      576.,  37.,  74.,   111., 148., 190., 228.,  266.,  304., 351., 390.,
      429.,  468., 520.,  560., 600., 640., 41.,   82.,   123., 164., 210.,
      252.,  294., 336.,  387., 430., 473., 516.,  572.,  616., 660., 704.,
      45.,   90.,  135.,  180., 230., 276., 322.,  368.,  423., 470., 517.,
      564.,  624., 672.,  720., 768., 49.,  98.,   147.,  196., 250., 300.,
      350.,  400., 459.,  510., 561., 612., 676.,  728.,  780., 832., 53.,
      106.,  159., 212.,  270., 324., 378., 432.,  495.,  550., 605., 660.,
      728.,  784., 840.,  896., 57.,  114., 171.,  228.,  290., 348., 406.,
      464.,  531., 590.,  649., 708., 780., 840.,  900.,  960., 61.,  122.,
      183.,  244., 310.,  372., 434., 496., 567.,  630.,  693., 756., 832.,
      896.,  960., 1024., 65.,  130., 195., 260.,  330.,  396., 462., 528.,
      603.,  670., 737.,  804., 884., 952., 1020., 1088., 69.,  138., 207.,
      276.,  350., 420.,  490., 560., 639., 710.,  781.,  852., 936., 1008.,
      1080., 1152.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12.,
      7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24.,
      13., 26., 14., 28., 15., 30., 16., 32., 17., 34., 18., 36.,
      19., 38., 20., 40., 21., 42., 22., 44., 23., 46., 24., 48.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12.,
      7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24.,
      13., 26., 14., 28., 15., 30., 16., 32., 17., 34., 18., 36.,
      19., 38., 20., 40., 21., 42., 22., 44., 23., 46., 24., 48.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,
      12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14., 21., 28.,
      8.,  16., 24., 32., 9.,  18., 27., 36., 10., 20., 30., 40., 11., 22.,
      33., 44., 12., 24., 36., 48., 13., 26., 39., 52., 14., 28., 42., 56.,
      15., 30., 45., 60., 16., 32., 48., 64., 17., 34., 51., 68., 18., 36.,
      54., 72., 19., 38., 57., 76., 20., 40., 60., 80., 21., 42., 63., 84.,
      22., 44., 66., 88., 23., 46., 69., 92., 24., 48., 72., 96.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,
      12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14., 21., 28.,
      8.,  16., 24., 32., 9.,  18., 27., 36., 10., 20., 30., 40., 11., 22.,
      33., 44., 12., 24., 36., 48., 13., 26., 39., 52., 14., 28., 42., 56.,
      15., 30., 45., 60., 16., 32., 48., 64., 17., 34., 51., 68., 18., 36.,
      54., 72., 19., 38., 57., 76., 20., 40., 60., 80., 21., 42., 63., 84.,
      22., 44., 66., 88., 23., 46., 69., 92., 24., 48., 72., 96.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  3.,  8.,  5.,  12., 7.,  16., 9.,  20., 11., 24.,
      13., 28., 15., 32., 17., 36., 19., 40., 21., 44., 23., 48.,
      25., 52., 27., 56., 29., 60., 31., 64., 33., 68., 35., 72.,
      37., 76., 39., 80., 41., 84., 43., 88., 45., 92., 47., 96.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  3.,  8.,  5.,  12., 7.,  16., 9.,  20., 11., 24.,
      13., 28., 15., 32., 17., 36., 19., 40., 21., 44., 23., 48.,
      25., 52., 27., 56., 29., 60., 31., 64., 33., 68., 35., 72.,
      37., 76., 39., 80., 41., 84., 43., 88., 45., 92., 47., 96.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,   8.,   3.,  6.,  12.,  16.,  5.,  10., 18.,  24.,
      7.,  14., 24.,  32.,  9.,  18., 30.,  40.,  11., 22., 36.,  48.,
      13., 26., 42.,  56.,  15., 30., 48.,  64.,  17., 34., 54.,  72.,
      19., 38., 60.,  80.,  21., 42., 66.,  88.,  23., 46., 72.,  96.,
      25., 50., 78.,  104., 27., 54., 84.,  112., 29., 58., 90.,  120.,
      31., 62., 96.,  128., 33., 66., 102., 136., 35., 70., 108., 144.,
      37., 74., 114., 152., 39., 78., 120., 160., 41., 82., 126., 168.,
      43., 86., 132., 176., 45., 90., 138., 184., 47., 94., 144., 192.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,   8.,   3.,  6.,  12.,  16.,  5.,  10., 18.,  24.,
      7.,  14., 24.,  32.,  9.,  18., 30.,  40.,  11., 22., 36.,  48.,
      13., 26., 42.,  56.,  15., 30., 48.,  64.,  17., 34., 54.,  72.,
      19., 38., 60.,  80.,  21., 42., 66.,  88.,  23., 46., 72.,  96.,
      25., 50., 78.,  104., 27., 54., 84.,  112., 29., 58., 90.,  120.,
      31., 62., 96.,  128., 33., 66., 102., 136., 35., 70., 108., 144.,
      37., 74., 114., 152., 39., 78., 120., 160., 41., 82., 126., 168.,
      43., 86., 132., 176., 45., 90., 138., 184., 47., 94., 144., 192.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  3.,   6.,   9.,   12.,
      20.,  24.,  28.,  32.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      7.,   14.,  21.,  28.,  40.,  48.,  56.,  64.,  9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  11.,  22.,  33.,  44.,  60.,  72.,  84.,  96.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 15.,  30.,  45.,  60.,
      80.,  96.,  112., 128., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      19.,  38.,  57.,  76.,  100., 120., 140., 160., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 23.,  46.,  69.,  92.,  120., 144., 168., 192.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 27.,  54.,  81.,  108.,
      140., 168., 196., 224., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      31.,  62.,  93.,  124., 160., 192., 224., 256., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 35.,  70.,  105., 140., 180., 216., 252., 288.,
      37.,  74.,  111., 148., 190., 228., 266., 304., 39.,  78.,  117., 156.,
      200., 240., 280., 320., 41.,  82.,  123., 164., 210., 252., 294., 336.,
      43.,  86.,  129., 172., 220., 264., 308., 352., 45.,  90.,  135., 180.,
      230., 276., 322., 368., 47.,  94.,  141., 188., 240., 288., 336., 384.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  3.,   6.,   9.,   12.,
      20.,  24.,  28.,  32.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      7.,   14.,  21.,  28.,  40.,  48.,  56.,  64.,  9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  11.,  22.,  33.,  44.,  60.,  72.,  84.,  96.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 15.,  30.,  45.,  60.,
      80.,  96.,  112., 128., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      19.,  38.,  57.,  76.,  100., 120., 140., 160., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 23.,  46.,  69.,  92.,  120., 144., 168., 192.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 27.,  54.,  81.,  108.,
      140., 168., 196., 224., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      31.,  62.,  93.,  124., 160., 192., 224., 256., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 35.,  70.,  105., 140., 180., 216., 252., 288.,
      37.,  74.,  111., 148., 190., 228., 266., 304., 39.,  78.,  117., 156.,
      200., 240., 280., 320., 41.,  82.,  123., 164., 210., 252., 294., 336.,
      43.,  86.,  129., 172., 220., 264., 308., 352., 45.,  90.,  135., 180.,
      230., 276., 322., 368., 47.,  94.,  141., 188., 240., 288., 336., 384.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,   9.,   16.,  5.,  12.,  21.,  32.,  9.,  20.,  33.,  48.,
      13., 28.,  45.,  64.,  17., 36.,  57.,  80.,  21., 44.,  69.,  96.,
      25., 52.,  81.,  112., 29., 60.,  93.,  128., 33., 68.,  105., 144.,
      37., 76.,  117., 160., 41., 84.,  129., 176., 45., 92.,  141., 192.,
      49., 100., 153., 208., 53., 108., 165., 224., 57., 116., 177., 240.,
      61., 124., 189., 256., 65., 132., 201., 272., 69., 140., 213., 288.,
      73., 148., 225., 304., 77., 156., 237., 320., 81., 164., 249., 336.,
      85., 172., 261., 352., 89., 180., 273., 368., 93., 188., 285., 384.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,   9.,   16.,  5.,  12.,  21.,  32.,  9.,  20.,  33.,  48.,
      13., 28.,  45.,  64.,  17., 36.,  57.,  80.,  21., 44.,  69.,  96.,
      25., 52.,  81.,  112., 29., 60.,  93.,  128., 33., 68.,  105., 144.,
      37., 76.,  117., 160., 41., 84.,  129., 176., 45., 92.,  141., 192.,
      49., 100., 153., 208., 53., 108., 165., 224., 57., 116., 177., 240.,
      61., 124., 189., 256., 65., 132., 201., 272., 69., 140., 213., 288.,
      73., 148., 225., 304., 77., 156., 237., 320., 81., 164., 249., 336.,
      85., 172., 261., 352., 89., 180., 273., 368., 93., 188., 285., 384.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   6.,   8.,   15.,  18.,  28.,  32.,  5.,   10.,  18.,  24.,
      35.,  42.,  56.,  64.,  9.,   18.,  30.,  40.,  55.,  66.,  84.,  96.,
      13.,  26.,  42.,  56.,  75.,  90.,  112., 128., 17.,  34.,  54.,  72.,
      95.,  114., 140., 160., 21.,  42.,  66.,  88.,  115., 138., 168., 192.,
      25.,  50.,  78.,  104., 135., 162., 196., 224., 29.,  58.,  90.,  120.,
      155., 186., 224., 256., 33.,  66.,  102., 136., 175., 210., 252., 288.,
      37.,  74.,  114., 152., 195., 234., 280., 320., 41.,  82.,  126., 168.,
      215., 258., 308., 352., 45.,  90.,  138., 184., 235., 282., 336., 384.,
      49.,  98.,  150., 200., 255., 306., 364., 416., 53.,  106., 162., 216.,
      275., 330., 392., 448., 57.,  114., 174., 232., 295., 354., 420., 480.,
      61.,  122., 186., 248., 315., 378., 448., 512., 65.,  130., 198., 264.,
      335., 402., 476., 544., 69.,  138., 210., 280., 355., 426., 504., 576.,
      73.,  146., 222., 296., 375., 450., 532., 608., 77.,  154., 234., 312.,
      395., 474., 560., 640., 81.,  162., 246., 328., 415., 498., 588., 672.,
      85.,  170., 258., 344., 435., 522., 616., 704., 89.,  178., 270., 360.,
      455., 546., 644., 736., 93.,  186., 282., 376., 475., 570., 672., 768.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   6.,   8.,   15.,  18.,  28.,  32.,  5.,   10.,  18.,  24.,
      35.,  42.,  56.,  64.,  9.,   18.,  30.,  40.,  55.,  66.,  84.,  96.,
      13.,  26.,  42.,  56.,  75.,  90.,  112., 128., 17.,  34.,  54.,  72.,
      95.,  114., 140., 160., 21.,  42.,  66.,  88.,  115., 138., 168., 192.,
      25.,  50.,  78.,  104., 135., 162., 196., 224., 29.,  58.,  90.,  120.,
      155., 186., 224., 256., 33.,  66.,  102., 136., 175., 210., 252., 288.,
      37.,  74.,  114., 152., 195., 234., 280., 320., 41.,  82.,  126., 168.,
      215., 258., 308., 352., 45.,  90.,  138., 184., 235., 282., 336., 384.,
      49.,  98.,  150., 200., 255., 306., 364., 416., 53.,  106., 162., 216.,
      275., 330., 392., 448., 57.,  114., 174., 232., 295., 354., 420., 480.,
      61.,  122., 186., 248., 315., 378., 448., 512., 65.,  130., 198., 264.,
      335., 402., 476., 544., 69.,  138., 210., 280., 355., 426., 504., 576.,
      73.,  146., 222., 296., 375., 450., 532., 608., 77.,  154., 234., 312.,
      395., 474., 560., 640., 81.,  162., 246., 328., 415., 498., 588., 672.,
      85.,  170., 258., 344., 435., 522., 616., 704., 89.,  178., 270., 360.,
      455., 546., 644., 736., 93.,  186., 282., 376., 475., 570., 672., 768.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    3.,    4.,    10.,   12.,   14.,   16.,   27.,   30.,
      33.,   36.,   52.,   56.,   60.,   64.,   5.,    10.,   15.,   20.,
      30.,   36.,   42.,   48.,   63.,   70.,   77.,   84.,   104.,  112.,
      120.,  128.,  9.,    18.,   27.,   36.,   50.,   60.,   70.,   80.,
      99.,   110.,  121.,  132.,  156.,  168.,  180.,  192.,  13.,   26.,
      39.,   52.,   70.,   84.,   98.,   112.,  135.,  150.,  165.,  180.,
      208.,  224.,  240.,  256.,  17.,   34.,   51.,   68.,   90.,   108.,
      126.,  144.,  171.,  190.,  209.,  228.,  260.,  280.,  300.,  320.,
      21.,   42.,   63.,   84.,   110.,  132.,  154.,  176.,  207.,  230.,
      253.,  276.,  312.,  336.,  360.,  384.,  25.,   50.,   75.,   100.,
      130.,  156.,  182.,  208.,  243.,  270.,  297.,  324.,  364.,  392.,
      420.,  448.,  29.,   58.,   87.,   116.,  150.,  180.,  210.,  240.,
      279.,  310.,  341.,  372.,  416.,  448.,  480.,  512.,  33.,   66.,
      99.,   132.,  170.,  204.,  238.,  272.,  315.,  350.,  385.,  420.,
      468.,  504.,  540.,  576.,  37.,   74.,   111.,  148.,  190.,  228.,
      266.,  304.,  351.,  390.,  429.,  468.,  520.,  560.,  600.,  640.,
      41.,   82.,   123.,  164.,  210.,  252.,  294.,  336.,  387.,  430.,
      473.,  516.,  572.,  616.,  660.,  704.,  45.,   90.,   135.,  180.,
      230.,  276.,  322.,  368.,  423.,  470.,  517.,  564.,  624.,  672.,
      720.,  768.,  49.,   98.,   147.,  196.,  250.,  300.,  350.,  400.,
      459.,  510.,  561.,  612.,  676.,  728.,  780.,  832.,  53.,   106.,
      159.,  212.,  270.,  324.,  378.,  432.,  495.,  550.,  605.,  660.,
      728.,  784.,  840.,  896.,  57.,   114.,  171.,  228.,  290.,  348.,
      406.,  464.,  531.,  590.,  649.,  708.,  780.,  840.,  900.,  960.,
      61.,   122.,  183.,  244.,  310.,  372.,  434.,  496.,  567.,  630.,
      693.,  756.,  832.,  896.,  960.,  1024., 65.,   130.,  195.,  260.,
      330.,  396.,  462.,  528.,  603.,  670.,  737.,  804.,  884.,  952.,
      1020., 1088., 69.,   138.,  207.,  276.,  350.,  420.,  490.,  560.,
      639.,  710.,  781.,  852.,  936.,  1008., 1080., 1152., 73.,   146.,
      219.,  292.,  370.,  444.,  518.,  592.,  675.,  750.,  825.,  900.,
      988.,  1064., 1140., 1216., 77.,   154.,  231.,  308.,  390.,  468.,
      546.,  624.,  711.,  790.,  869.,  948.,  1040., 1120., 1200., 1280.,
      81.,   162.,  243.,  324.,  410.,  492.,  574.,  656.,  747.,  830.,
      913.,  996.,  1092., 1176., 1260., 1344., 85.,   170.,  255.,  340.,
      430.,  516.,  602.,  688.,  783.,  870.,  957.,  1044., 1144., 1232.,
      1320., 1408., 89.,   178.,  267.,  356.,  450.,  540.,  630.,  720.,
      819.,  910.,  1001., 1092., 1196., 1288., 1380., 1472., 93.,   186.,
      279.,  372.,  470.,  564.,  658.,  752.,  855.,  950.,  1045., 1140.,
      1248., 1344., 1440., 1536.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    3.,    4.,    10.,   12.,   14.,   16.,   27.,   30.,
      33.,   36.,   52.,   56.,   60.,   64.,   5.,    10.,   15.,   20.,
      30.,   36.,   42.,   48.,   63.,   70.,   77.,   84.,   104.,  112.,
      120.,  128.,  9.,    18.,   27.,   36.,   50.,   60.,   70.,   80.,
      99.,   110.,  121.,  132.,  156.,  168.,  180.,  192.,  13.,   26.,
      39.,   52.,   70.,   84.,   98.,   112.,  135.,  150.,  165.,  180.,
      208.,  224.,  240.,  256.,  17.,   34.,   51.,   68.,   90.,   108.,
      126.,  144.,  171.,  190.,  209.,  228.,  260.,  280.,  300.,  320.,
      21.,   42.,   63.,   84.,   110.,  132.,  154.,  176.,  207.,  230.,
      253.,  276.,  312.,  336.,  360.,  384.,  25.,   50.,   75.,   100.,
      130.,  156.,  182.,  208.,  243.,  270.,  297.,  324.,  364.,  392.,
      420.,  448.,  29.,   58.,   87.,   116.,  150.,  180.,  210.,  240.,
      279.,  310.,  341.,  372.,  416.,  448.,  480.,  512.,  33.,   66.,
      99.,   132.,  170.,  204.,  238.,  272.,  315.,  350.,  385.,  420.,
      468.,  504.,  540.,  576.,  37.,   74.,   111.,  148.,  190.,  228.,
      266.,  304.,  351.,  390.,  429.,  468.,  520.,  560.,  600.,  640.,
      41.,   82.,   123.,  164.,  210.,  252.,  294.,  336.,  387.,  430.,
      473.,  516.,  572.,  616.,  660.,  704.,  45.,   90.,   135.,  180.,
      230.,  276.,  322.,  368.,  423.,  470.,  517.,  564.,  624.,  672.,
      720.,  768.,  49.,   98.,   147.,  196.,  250.,  300.,  350.,  400.,
      459.,  510.,  561.,  612.,  676.,  728.,  780.,  832.,  53.,   106.,
      159.,  212.,  270.,  324.,  378.,  432.,  495.,  550.,  605.,  660.,
      728.,  784.,  840.,  896.,  57.,   114.,  171.,  228.,  290.,  348.,
      406.,  464.,  531.,  590.,  649.,  708.,  780.,  840.,  900.,  960.,
      61.,   122.,  183.,  244.,  310.,  372.,  434.,  496.,  567.,  630.,
      693.,  756.,  832.,  896.,  960.,  1024., 65.,   130.,  195.,  260.,
      330.,  396.,  462.,  528.,  603.,  670.,  737.,  804.,  884.,  952.,
      1020., 1088., 69.,   138.,  207.,  276.,  350.,  420.,  490.,  560.,
      639.,  710.,  781.,  852.,  936.,  1008., 1080., 1152., 73.,   146.,
      219.,  292.,  370.,  444.,  518.,  592.,  675.,  750.,  825.,  900.,
      988.,  1064., 1140., 1216., 77.,   154.,  231.,  308.,  390.,  468.,
      546.,  624.,  711.,  790.,  869.,  948.,  1040., 1120., 1200., 1280.,
      81.,   162.,  243.,  324.,  410.,  492.,  574.,  656.,  747.,  830.,
      913.,  996.,  1092., 1176., 1260., 1344., 85.,   170.,  255.,  340.,
      430.,  516.,  602.,  688.,  783.,  870.,  957.,  1044., 1144., 1232.,
      1320., 1408., 89.,   178.,  267.,  356.,  450.,  540.,  630.,  720.,
      819.,  910.,  1001., 1092., 1196., 1288., 1380., 1472., 93.,   186.,
      279.,  372.,  470.,  564.,  658.,  752.,  855.,  950.,  1045., 1140.,
      1248., 1344., 1440., 1536.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  4.,  5.,  6.,
                                         7.,  8.,  9.,  10., 11., 12.,
                                         13., 14., 15., 16., 17., 18.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  4.,  5.,  6.,
                                         7.,  8.,  9.,  10., 11., 12.,
                                         13., 14., 15., 16., 17., 18.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12.,
      7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24.,
      13., 26., 14., 28., 15., 30., 16., 32., 17., 34., 18., 36.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12.,
      7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24.,
      13., 26., 14., 28., 15., 30., 16., 32., 17., 34., 18., 36.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,  12.,
      16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14., 21., 28., 8.,  16.,
      24., 32., 9.,  18., 27., 36., 10., 20., 30., 40., 11., 22., 33., 44., 12.,
      24., 36., 48., 13., 26., 39., 52., 14., 28., 42., 56., 15., 30., 45., 60.,
      16., 32., 48., 64., 17., 34., 51., 68., 18., 36., 54., 72.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,  12.,
      16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14., 21., 28., 8.,  16.,
      24., 32., 9.,  18., 27., 36., 10., 20., 30., 40., 11., 22., 33., 44., 12.,
      24., 36., 48., 13., 26., 39., 52., 14., 28., 42., 56., 15., 30., 45., 60.,
      16., 32., 48., 64., 17., 34., 51., 68., 18., 36., 54., 72.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  3.,  8.,  5.,  12., 7.,  16., 9.,  20., 11., 24.,
      13., 28., 15., 32., 17., 36., 19., 40., 21., 44., 23., 48.,
      25., 52., 27., 56., 29., 60., 31., 64., 33., 68., 35., 72.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  3.,  8.,  5.,  12., 7.,  16., 9.,  20., 11., 24.,
      13., 28., 15., 32., 17., 36., 19., 40., 21., 44., 23., 48.,
      25., 52., 27., 56., 29., 60., 31., 64., 33., 68., 35., 72.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,  8.,   3.,  6.,  12.,  16.,  5.,  10., 18.,  24.,
      7.,  14., 24., 32.,  9.,  18., 30.,  40.,  11., 22., 36.,  48.,
      13., 26., 42., 56.,  15., 30., 48.,  64.,  17., 34., 54.,  72.,
      19., 38., 60., 80.,  21., 42., 66.,  88.,  23., 46., 72.,  96.,
      25., 50., 78., 104., 27., 54., 84.,  112., 29., 58., 90.,  120.,
      31., 62., 96., 128., 33., 66., 102., 136., 35., 70., 108., 144.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,  8.,   3.,  6.,  12.,  16.,  5.,  10., 18.,  24.,
      7.,  14., 24., 32.,  9.,  18., 30.,  40.,  11., 22., 36.,  48.,
      13., 26., 42., 56.,  15., 30., 48.,  64.,  17., 34., 54.,  72.,
      19., 38., 60., 80.,  21., 42., 66.,  88.,  23., 46., 72.,  96.,
      25., 50., 78., 104., 27., 54., 84.,  112., 29., 58., 90.,  120.,
      31., 62., 96., 128., 33., 66., 102., 136., 35., 70., 108., 144.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  3.,   6.,   9.,   12.,
      20.,  24.,  28.,  32.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      7.,   14.,  21.,  28.,  40.,  48.,  56.,  64.,  9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  11.,  22.,  33.,  44.,  60.,  72.,  84.,  96.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 15.,  30.,  45.,  60.,
      80.,  96.,  112., 128., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      19.,  38.,  57.,  76.,  100., 120., 140., 160., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 23.,  46.,  69.,  92.,  120., 144., 168., 192.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 27.,  54.,  81.,  108.,
      140., 168., 196., 224., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      31.,  62.,  93.,  124., 160., 192., 224., 256., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 35.,  70.,  105., 140., 180., 216., 252., 288.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  3.,   6.,   9.,   12.,
      20.,  24.,  28.,  32.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      7.,   14.,  21.,  28.,  40.,  48.,  56.,  64.,  9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  11.,  22.,  33.,  44.,  60.,  72.,  84.,  96.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 15.,  30.,  45.,  60.,
      80.,  96.,  112., 128., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      19.,  38.,  57.,  76.,  100., 120., 140., 160., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 23.,  46.,  69.,  92.,  120., 144., 168., 192.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 27.,  54.,  81.,  108.,
      140., 168., 196., 224., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      31.,  62.,  93.,  124., 160., 192., 224., 256., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 35.,  70.,  105., 140., 180., 216., 252., 288.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,   9.,   16.,  5.,  12.,  21.,  32.,  9.,  20.,  33.,  48.,
      13., 28.,  45.,  64.,  17., 36.,  57.,  80.,  21., 44.,  69.,  96.,
      25., 52.,  81.,  112., 29., 60.,  93.,  128., 33., 68.,  105., 144.,
      37., 76.,  117., 160., 41., 84.,  129., 176., 45., 92.,  141., 192.,
      49., 100., 153., 208., 53., 108., 165., 224., 57., 116., 177., 240.,
      61., 124., 189., 256., 65., 132., 201., 272., 69., 140., 213., 288.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,   9.,   16.,  5.,  12.,  21.,  32.,  9.,  20.,  33.,  48.,
      13., 28.,  45.,  64.,  17., 36.,  57.,  80.,  21., 44.,  69.,  96.,
      25., 52.,  81.,  112., 29., 60.,  93.,  128., 33., 68.,  105., 144.,
      37., 76.,  117., 160., 41., 84.,  129., 176., 45., 92.,  141., 192.,
      49., 100., 153., 208., 53., 108., 165., 224., 57., 116., 177., 240.,
      61., 124., 189., 256., 65., 132., 201., 272., 69., 140., 213., 288.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   6.,   8.,   15.,  18.,  28.,  32.,  5.,   10.,  18.,  24.,
      35.,  42.,  56.,  64.,  9.,   18.,  30.,  40.,  55.,  66.,  84.,  96.,
      13.,  26.,  42.,  56.,  75.,  90.,  112., 128., 17.,  34.,  54.,  72.,
      95.,  114., 140., 160., 21.,  42.,  66.,  88.,  115., 138., 168., 192.,
      25.,  50.,  78.,  104., 135., 162., 196., 224., 29.,  58.,  90.,  120.,
      155., 186., 224., 256., 33.,  66.,  102., 136., 175., 210., 252., 288.,
      37.,  74.,  114., 152., 195., 234., 280., 320., 41.,  82.,  126., 168.,
      215., 258., 308., 352., 45.,  90.,  138., 184., 235., 282., 336., 384.,
      49.,  98.,  150., 200., 255., 306., 364., 416., 53.,  106., 162., 216.,
      275., 330., 392., 448., 57.,  114., 174., 232., 295., 354., 420., 480.,
      61.,  122., 186., 248., 315., 378., 448., 512., 65.,  130., 198., 264.,
      335., 402., 476., 544., 69.,  138., 210., 280., 355., 426., 504., 576.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   6.,   8.,   15.,  18.,  28.,  32.,  5.,   10.,  18.,  24.,
      35.,  42.,  56.,  64.,  9.,   18.,  30.,  40.,  55.,  66.,  84.,  96.,
      13.,  26.,  42.,  56.,  75.,  90.,  112., 128., 17.,  34.,  54.,  72.,
      95.,  114., 140., 160., 21.,  42.,  66.,  88.,  115., 138., 168., 192.,
      25.,  50.,  78.,  104., 135., 162., 196., 224., 29.,  58.,  90.,  120.,
      155., 186., 224., 256., 33.,  66.,  102., 136., 175., 210., 252., 288.,
      37.,  74.,  114., 152., 195., 234., 280., 320., 41.,  82.,  126., 168.,
      215., 258., 308., 352., 45.,  90.,  138., 184., 235., 282., 336., 384.,
      49.,  98.,  150., 200., 255., 306., 364., 416., 53.,  106., 162., 216.,
      275., 330., 392., 448., 57.,  114., 174., 232., 295., 354., 420., 480.,
      61.,  122., 186., 248., 315., 378., 448., 512., 65.,  130., 198., 264.,
      335., 402., 476., 544., 69.,  138., 210., 280., 355., 426., 504., 576.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,   3.,    4.,   10.,  12.,  14.,   16.,   27.,  30.,  33.,
      36.,   52.,  56.,   60.,  64.,  5.,   10.,   15.,   20.,  30.,  36.,
      42.,   48.,  63.,   70.,  77.,  84.,  104.,  112.,  120., 128., 9.,
      18.,   27.,  36.,   50.,  60.,  70.,  80.,   99.,   110., 121., 132.,
      156.,  168., 180.,  192., 13.,  26.,  39.,   52.,   70.,  84.,  98.,
      112.,  135., 150.,  165., 180., 208., 224.,  240.,  256., 17.,  34.,
      51.,   68.,  90.,   108., 126., 144., 171.,  190.,  209., 228., 260.,
      280.,  300., 320.,  21.,  42.,  63.,  84.,   110.,  132., 154., 176.,
      207.,  230., 253.,  276., 312., 336., 360.,  384.,  25.,  50.,  75.,
      100.,  130., 156.,  182., 208., 243., 270.,  297.,  324., 364., 392.,
      420.,  448., 29.,   58.,  87.,  116., 150.,  180.,  210., 240., 279.,
      310.,  341., 372.,  416., 448., 480., 512.,  33.,   66.,  99.,  132.,
      170.,  204., 238.,  272., 315., 350., 385.,  420.,  468., 504., 540.,
      576.,  37.,  74.,   111., 148., 190., 228.,  266.,  304., 351., 390.,
      429.,  468., 520.,  560., 600., 640., 41.,   82.,   123., 164., 210.,
      252.,  294., 336.,  387., 430., 473., 516.,  572.,  616., 660., 704.,
      45.,   90.,  135.,  180., 230., 276., 322.,  368.,  423., 470., 517.,
      564.,  624., 672.,  720., 768., 49.,  98.,   147.,  196., 250., 300.,
      350.,  400., 459.,  510., 561., 612., 676.,  728.,  780., 832., 53.,
      106.,  159., 212.,  270., 324., 378., 432.,  495.,  550., 605., 660.,
      728.,  784., 840.,  896., 57.,  114., 171.,  228.,  290., 348., 406.,
      464.,  531., 590.,  649., 708., 780., 840.,  900.,  960., 61.,  122.,
      183.,  244., 310.,  372., 434., 496., 567.,  630.,  693., 756., 832.,
      896.,  960., 1024., 65.,  130., 195., 260.,  330.,  396., 462., 528.,
      603.,  670., 737.,  804., 884., 952., 1020., 1088., 69.,  138., 207.,
      276.,  350., 420.,  490., 560., 639., 710.,  781.,  852., 936., 1008.,
      1080., 1152.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,   3.,    4.,   10.,  12.,  14.,   16.,   27.,  30.,  33.,
      36.,   52.,  56.,   60.,  64.,  5.,   10.,   15.,   20.,  30.,  36.,
      42.,   48.,  63.,   70.,  77.,  84.,  104.,  112.,  120., 128., 9.,
      18.,   27.,  36.,   50.,  60.,  70.,  80.,   99.,   110., 121., 132.,
      156.,  168., 180.,  192., 13.,  26.,  39.,   52.,   70.,  84.,  98.,
      112.,  135., 150.,  165., 180., 208., 224.,  240.,  256., 17.,  34.,
      51.,   68.,  90.,   108., 126., 144., 171.,  190.,  209., 228., 260.,
      280.,  300., 320.,  21.,  42.,  63.,  84.,   110.,  132., 154., 176.,
      207.,  230., 253.,  276., 312., 336., 360.,  384.,  25.,  50.,  75.,
      100.,  130., 156.,  182., 208., 243., 270.,  297.,  324., 364., 392.,
      420.,  448., 29.,   58.,  87.,  116., 150.,  180.,  210., 240., 279.,
      310.,  341., 372.,  416., 448., 480., 512.,  33.,   66.,  99.,  132.,
      170.,  204., 238.,  272., 315., 350., 385.,  420.,  468., 504., 540.,
      576.,  37.,  74.,   111., 148., 190., 228.,  266.,  304., 351., 390.,
      429.,  468., 520.,  560., 600., 640., 41.,   82.,   123., 164., 210.,
      252.,  294., 336.,  387., 430., 473., 516.,  572.,  616., 660., 704.,
      45.,   90.,  135.,  180., 230., 276., 322.,  368.,  423., 470., 517.,
      564.,  624., 672.,  720., 768., 49.,  98.,   147.,  196., 250., 300.,
      350.,  400., 459.,  510., 561., 612., 676.,  728.,  780., 832., 53.,
      106.,  159., 212.,  270., 324., 378., 432.,  495.,  550., 605., 660.,
      728.,  784., 840.,  896., 57.,  114., 171.,  228.,  290., 348., 406.,
      464.,  531., 590.,  649., 708., 780., 840.,  900.,  960., 61.,  122.,
      183.,  244., 310.,  372., 434., 496., 567.,  630.,  693., 756., 832.,
      896.,  960., 1024., 65.,  130., 195., 260.,  330.,  396., 462., 528.,
      603.,  670., 737.,  804., 884., 952., 1020., 1088., 69.,  138., 207.,
      276.,  350., 420.,  490., 560., 639., 710.,  781.,  852., 936., 1008.,
      1080., 1152.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13., 14.,
      15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13., 14.,
      15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12., 7.,  14.,
      8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24., 13., 26., 14., 28.,
      15., 30., 16., 32., 17., 34., 18., 36., 19., 38., 20., 40., 21., 42.,
      22., 44., 23., 46., 24., 48., 25., 50., 26., 52., 27., 54.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12., 7.,  14.,
      8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24., 13., 26., 14., 28.,
      15., 30., 16., 32., 17., 34., 18., 36., 19., 38., 20., 40., 21., 42.,
      22., 44., 23., 46., 24., 48., 25., 50., 26., 52., 27., 54.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,   3.,  4.,  2.,  4.,   6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,
      12., 16.,  5.,  10., 15., 20.,  6.,  12., 18., 24., 7.,  14., 21., 28.,
      8.,  16.,  24., 32., 9.,  18.,  27., 36., 10., 20., 30., 40., 11., 22.,
      33., 44.,  12., 24., 36., 48.,  13., 26., 39., 52., 14., 28., 42., 56.,
      15., 30.,  45., 60., 16., 32.,  48., 64., 17., 34., 51., 68., 18., 36.,
      54., 72.,  19., 38., 57., 76.,  20., 40., 60., 80., 21., 42., 63., 84.,
      22., 44.,  66., 88., 23., 46.,  69., 92., 24., 48., 72., 96., 25., 50.,
      75., 100., 26., 52., 78., 104., 27., 54., 81., 108.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,   3.,  4.,  2.,  4.,   6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,
      12., 16.,  5.,  10., 15., 20.,  6.,  12., 18., 24., 7.,  14., 21., 28.,
      8.,  16.,  24., 32., 9.,  18.,  27., 36., 10., 20., 30., 40., 11., 22.,
      33., 44.,  12., 24., 36., 48.,  13., 26., 39., 52., 14., 28., 42., 56.,
      15., 30.,  45., 60., 16., 32.,  48., 64., 17., 34., 51., 68., 18., 36.,
      54., 72.,  19., 38., 57., 76.,  20., 40., 60., 80., 21., 42., 63., 84.,
      22., 44.,  66., 88., 23., 46.,  69., 92., 24., 48., 72., 96., 25., 50.,
      75., 100., 26., 52., 78., 104., 27., 54., 81., 108.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  3.,  8.,  5.,  12., 7.,  16.,  9.,  20.,  11., 24., 13., 28.,
      15., 32., 17., 36., 19., 40., 21., 44.,  23., 48.,  25., 52., 27., 56.,
      29., 60., 31., 64., 33., 68., 35., 72.,  37., 76.,  39., 80., 41., 84.,
      43., 88., 45., 92., 47., 96., 49., 100., 51., 104., 53., 108.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  3.,  8.,  5.,  12., 7.,  16.,  9.,  20.,  11., 24., 13., 28.,
      15., 32., 17., 36., 19., 40., 21., 44.,  23., 48.,  25., 52., 27., 56.,
      29., 60., 31., 64., 33., 68., 35., 72.,  37., 76.,  39., 80., 41., 84.,
      43., 88., 45., 92., 47., 96., 49., 100., 51., 104., 53., 108.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,   8.,   3.,  6.,   12.,  16.,  5.,  10.,  18.,  24.,
      7.,  14., 24.,  32.,  9.,  18.,  30.,  40.,  11., 22.,  36.,  48.,
      13., 26., 42.,  56.,  15., 30.,  48.,  64.,  17., 34.,  54.,  72.,
      19., 38., 60.,  80.,  21., 42.,  66.,  88.,  23., 46.,  72.,  96.,
      25., 50., 78.,  104., 27., 54.,  84.,  112., 29., 58.,  90.,  120.,
      31., 62., 96.,  128., 33., 66.,  102., 136., 35., 70.,  108., 144.,
      37., 74., 114., 152., 39., 78.,  120., 160., 41., 82.,  126., 168.,
      43., 86., 132., 176., 45., 90.,  138., 184., 47., 94.,  144., 192.,
      49., 98., 150., 200., 51., 102., 156., 208., 53., 106., 162., 216.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,   8.,   3.,  6.,   12.,  16.,  5.,  10.,  18.,  24.,
      7.,  14., 24.,  32.,  9.,  18.,  30.,  40.,  11., 22.,  36.,  48.,
      13., 26., 42.,  56.,  15., 30.,  48.,  64.,  17., 34.,  54.,  72.,
      19., 38., 60.,  80.,  21., 42.,  66.,  88.,  23., 46.,  72.,  96.,
      25., 50., 78.,  104., 27., 54.,  84.,  112., 29., 58.,  90.,  120.,
      31., 62., 96.,  128., 33., 66.,  102., 136., 35., 70.,  108., 144.,
      37., 74., 114., 152., 39., 78.,  120., 160., 41., 82.,  126., 168.,
      43., 86., 132., 176., 45., 90.,  138., 184., 47., 94.,  144., 192.,
      49., 98., 150., 200., 51., 102., 156., 208., 53., 106., 162., 216.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  3.,   6.,   9.,   12.,
      20.,  24.,  28.,  32.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      7.,   14.,  21.,  28.,  40.,  48.,  56.,  64.,  9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  11.,  22.,  33.,  44.,  60.,  72.,  84.,  96.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 15.,  30.,  45.,  60.,
      80.,  96.,  112., 128., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      19.,  38.,  57.,  76.,  100., 120., 140., 160., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 23.,  46.,  69.,  92.,  120., 144., 168., 192.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 27.,  54.,  81.,  108.,
      140., 168., 196., 224., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      31.,  62.,  93.,  124., 160., 192., 224., 256., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 35.,  70.,  105., 140., 180., 216., 252., 288.,
      37.,  74.,  111., 148., 190., 228., 266., 304., 39.,  78.,  117., 156.,
      200., 240., 280., 320., 41.,  82.,  123., 164., 210., 252., 294., 336.,
      43.,  86.,  129., 172., 220., 264., 308., 352., 45.,  90.,  135., 180.,
      230., 276., 322., 368., 47.,  94.,  141., 188., 240., 288., 336., 384.,
      49.,  98.,  147., 196., 250., 300., 350., 400., 51.,  102., 153., 204.,
      260., 312., 364., 416., 53.,  106., 159., 212., 270., 324., 378., 432.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  3.,   6.,   9.,   12.,
      20.,  24.,  28.,  32.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      7.,   14.,  21.,  28.,  40.,  48.,  56.,  64.,  9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  11.,  22.,  33.,  44.,  60.,  72.,  84.,  96.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 15.,  30.,  45.,  60.,
      80.,  96.,  112., 128., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      19.,  38.,  57.,  76.,  100., 120., 140., 160., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 23.,  46.,  69.,  92.,  120., 144., 168., 192.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 27.,  54.,  81.,  108.,
      140., 168., 196., 224., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      31.,  62.,  93.,  124., 160., 192., 224., 256., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 35.,  70.,  105., 140., 180., 216., 252., 288.,
      37.,  74.,  111., 148., 190., 228., 266., 304., 39.,  78.,  117., 156.,
      200., 240., 280., 320., 41.,  82.,  123., 164., 210., 252., 294., 336.,
      43.,  86.,  129., 172., 220., 264., 308., 352., 45.,  90.,  135., 180.,
      230., 276., 322., 368., 47.,  94.,  141., 188., 240., 288., 336., 384.,
      49.,  98.,  147., 196., 250., 300., 350., 400., 51.,  102., 153., 204.,
      260., 312., 364., 416., 53.,  106., 159., 212., 270., 324., 378., 432.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,   9.,   16.,  5.,   12.,  21.,  32.,  9.,   20.,  33.,  48.,
      13., 28.,  45.,  64.,  17.,  36.,  57.,  80.,  21.,  44.,  69.,  96.,
      25., 52.,  81.,  112., 29.,  60.,  93.,  128., 33.,  68.,  105., 144.,
      37., 76.,  117., 160., 41.,  84.,  129., 176., 45.,  92.,  141., 192.,
      49., 100., 153., 208., 53.,  108., 165., 224., 57.,  116., 177., 240.,
      61., 124., 189., 256., 65.,  132., 201., 272., 69.,  140., 213., 288.,
      73., 148., 225., 304., 77.,  156., 237., 320., 81.,  164., 249., 336.,
      85., 172., 261., 352., 89.,  180., 273., 368., 93.,  188., 285., 384.,
      97., 196., 297., 400., 101., 204., 309., 416., 105., 212., 321., 432.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,   9.,   16.,  5.,   12.,  21.,  32.,  9.,   20.,  33.,  48.,
      13., 28.,  45.,  64.,  17.,  36.,  57.,  80.,  21.,  44.,  69.,  96.,
      25., 52.,  81.,  112., 29.,  60.,  93.,  128., 33.,  68.,  105., 144.,
      37., 76.,  117., 160., 41.,  84.,  129., 176., 45.,  92.,  141., 192.,
      49., 100., 153., 208., 53.,  108., 165., 224., 57.,  116., 177., 240.,
      61., 124., 189., 256., 65.,  132., 201., 272., 69.,  140., 213., 288.,
      73., 148., 225., 304., 77.,  156., 237., 320., 81.,  164., 249., 336.,
      85., 172., 261., 352., 89.,  180., 273., 368., 93.,  188., 285., 384.,
      97., 196., 297., 400., 101., 204., 309., 416., 105., 212., 321., 432.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   6.,   8.,   15.,  18.,  28.,  32.,  5.,   10.,  18.,  24.,
      35.,  42.,  56.,  64.,  9.,   18.,  30.,  40.,  55.,  66.,  84.,  96.,
      13.,  26.,  42.,  56.,  75.,  90.,  112., 128., 17.,  34.,  54.,  72.,
      95.,  114., 140., 160., 21.,  42.,  66.,  88.,  115., 138., 168., 192.,
      25.,  50.,  78.,  104., 135., 162., 196., 224., 29.,  58.,  90.,  120.,
      155., 186., 224., 256., 33.,  66.,  102., 136., 175., 210., 252., 288.,
      37.,  74.,  114., 152., 195., 234., 280., 320., 41.,  82.,  126., 168.,
      215., 258., 308., 352., 45.,  90.,  138., 184., 235., 282., 336., 384.,
      49.,  98.,  150., 200., 255., 306., 364., 416., 53.,  106., 162., 216.,
      275., 330., 392., 448., 57.,  114., 174., 232., 295., 354., 420., 480.,
      61.,  122., 186., 248., 315., 378., 448., 512., 65.,  130., 198., 264.,
      335., 402., 476., 544., 69.,  138., 210., 280., 355., 426., 504., 576.,
      73.,  146., 222., 296., 375., 450., 532., 608., 77.,  154., 234., 312.,
      395., 474., 560., 640., 81.,  162., 246., 328., 415., 498., 588., 672.,
      85.,  170., 258., 344., 435., 522., 616., 704., 89.,  178., 270., 360.,
      455., 546., 644., 736., 93.,  186., 282., 376., 475., 570., 672., 768.,
      97.,  194., 294., 392., 495., 594., 700., 800., 101., 202., 306., 408.,
      515., 618., 728., 832., 105., 210., 318., 424., 535., 642., 756., 864.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   6.,   8.,   15.,  18.,  28.,  32.,  5.,   10.,  18.,  24.,
      35.,  42.,  56.,  64.,  9.,   18.,  30.,  40.,  55.,  66.,  84.,  96.,
      13.,  26.,  42.,  56.,  75.,  90.,  112., 128., 17.,  34.,  54.,  72.,
      95.,  114., 140., 160., 21.,  42.,  66.,  88.,  115., 138., 168., 192.,
      25.,  50.,  78.,  104., 135., 162., 196., 224., 29.,  58.,  90.,  120.,
      155., 186., 224., 256., 33.,  66.,  102., 136., 175., 210., 252., 288.,
      37.,  74.,  114., 152., 195., 234., 280., 320., 41.,  82.,  126., 168.,
      215., 258., 308., 352., 45.,  90.,  138., 184., 235., 282., 336., 384.,
      49.,  98.,  150., 200., 255., 306., 364., 416., 53.,  106., 162., 216.,
      275., 330., 392., 448., 57.,  114., 174., 232., 295., 354., 420., 480.,
      61.,  122., 186., 248., 315., 378., 448., 512., 65.,  130., 198., 264.,
      335., 402., 476., 544., 69.,  138., 210., 280., 355., 426., 504., 576.,
      73.,  146., 222., 296., 375., 450., 532., 608., 77.,  154., 234., 312.,
      395., 474., 560., 640., 81.,  162., 246., 328., 415., 498., 588., 672.,
      85.,  170., 258., 344., 435., 522., 616., 704., 89.,  178., 270., 360.,
      455., 546., 644., 736., 93.,  186., 282., 376., 475., 570., 672., 768.,
      97.,  194., 294., 392., 495., 594., 700., 800., 101., 202., 306., 408.,
      515., 618., 728., 832., 105., 210., 318., 424., 535., 642., 756., 864.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    3.,    4.,    10.,   12.,   14.,   16.,   27.,   30.,
      33.,   36.,   52.,   56.,   60.,   64.,   5.,    10.,   15.,   20.,
      30.,   36.,   42.,   48.,   63.,   70.,   77.,   84.,   104.,  112.,
      120.,  128.,  9.,    18.,   27.,   36.,   50.,   60.,   70.,   80.,
      99.,   110.,  121.,  132.,  156.,  168.,  180.,  192.,  13.,   26.,
      39.,   52.,   70.,   84.,   98.,   112.,  135.,  150.,  165.,  180.,
      208.,  224.,  240.,  256.,  17.,   34.,   51.,   68.,   90.,   108.,
      126.,  144.,  171.,  190.,  209.,  228.,  260.,  280.,  300.,  320.,
      21.,   42.,   63.,   84.,   110.,  132.,  154.,  176.,  207.,  230.,
      253.,  276.,  312.,  336.,  360.,  384.,  25.,   50.,   75.,   100.,
      130.,  156.,  182.,  208.,  243.,  270.,  297.,  324.,  364.,  392.,
      420.,  448.,  29.,   58.,   87.,   116.,  150.,  180.,  210.,  240.,
      279.,  310.,  341.,  372.,  416.,  448.,  480.,  512.,  33.,   66.,
      99.,   132.,  170.,  204.,  238.,  272.,  315.,  350.,  385.,  420.,
      468.,  504.,  540.,  576.,  37.,   74.,   111.,  148.,  190.,  228.,
      266.,  304.,  351.,  390.,  429.,  468.,  520.,  560.,  600.,  640.,
      41.,   82.,   123.,  164.,  210.,  252.,  294.,  336.,  387.,  430.,
      473.,  516.,  572.,  616.,  660.,  704.,  45.,   90.,   135.,  180.,
      230.,  276.,  322.,  368.,  423.,  470.,  517.,  564.,  624.,  672.,
      720.,  768.,  49.,   98.,   147.,  196.,  250.,  300.,  350.,  400.,
      459.,  510.,  561.,  612.,  676.,  728.,  780.,  832.,  53.,   106.,
      159.,  212.,  270.,  324.,  378.,  432.,  495.,  550.,  605.,  660.,
      728.,  784.,  840.,  896.,  57.,   114.,  171.,  228.,  290.,  348.,
      406.,  464.,  531.,  590.,  649.,  708.,  780.,  840.,  900.,  960.,
      61.,   122.,  183.,  244.,  310.,  372.,  434.,  496.,  567.,  630.,
      693.,  756.,  832.,  896.,  960.,  1024., 65.,   130.,  195.,  260.,
      330.,  396.,  462.,  528.,  603.,  670.,  737.,  804.,  884.,  952.,
      1020., 1088., 69.,   138.,  207.,  276.,  350.,  420.,  490.,  560.,
      639.,  710.,  781.,  852.,  936.,  1008., 1080., 1152., 73.,   146.,
      219.,  292.,  370.,  444.,  518.,  592.,  675.,  750.,  825.,  900.,
      988.,  1064., 1140., 1216., 77.,   154.,  231.,  308.,  390.,  468.,
      546.,  624.,  711.,  790.,  869.,  948.,  1040., 1120., 1200., 1280.,
      81.,   162.,  243.,  324.,  410.,  492.,  574.,  656.,  747.,  830.,
      913.,  996.,  1092., 1176., 1260., 1344., 85.,   170.,  255.,  340.,
      430.,  516.,  602.,  688.,  783.,  870.,  957.,  1044., 1144., 1232.,
      1320., 1408., 89.,   178.,  267.,  356.,  450.,  540.,  630.,  720.,
      819.,  910.,  1001., 1092., 1196., 1288., 1380., 1472., 93.,   186.,
      279.,  372.,  470.,  564.,  658.,  752.,  855.,  950.,  1045., 1140.,
      1248., 1344., 1440., 1536., 97.,   194.,  291.,  388.,  490.,  588.,
      686.,  784.,  891.,  990.,  1089., 1188., 1300., 1400., 1500., 1600.,
      101.,  202.,  303.,  404.,  510.,  612.,  714.,  816.,  927.,  1030.,
      1133., 1236., 1352., 1456., 1560., 1664., 105.,  210.,  315.,  420.,
      530.,  636.,  742.,  848.,  963.,  1070., 1177., 1284., 1404., 1512.,
      1620., 1728.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    3.,    4.,    10.,   12.,   14.,   16.,   27.,   30.,
      33.,   36.,   52.,   56.,   60.,   64.,   5.,    10.,   15.,   20.,
      30.,   36.,   42.,   48.,   63.,   70.,   77.,   84.,   104.,  112.,
      120.,  128.,  9.,    18.,   27.,   36.,   50.,   60.,   70.,   80.,
      99.,   110.,  121.,  132.,  156.,  168.,  180.,  192.,  13.,   26.,
      39.,   52.,   70.,   84.,   98.,   112.,  135.,  150.,  165.,  180.,
      208.,  224.,  240.,  256.,  17.,   34.,   51.,   68.,   90.,   108.,
      126.,  144.,  171.,  190.,  209.,  228.,  260.,  280.,  300.,  320.,
      21.,   42.,   63.,   84.,   110.,  132.,  154.,  176.,  207.,  230.,
      253.,  276.,  312.,  336.,  360.,  384.,  25.,   50.,   75.,   100.,
      130.,  156.,  182.,  208.,  243.,  270.,  297.,  324.,  364.,  392.,
      420.,  448.,  29.,   58.,   87.,   116.,  150.,  180.,  210.,  240.,
      279.,  310.,  341.,  372.,  416.,  448.,  480.,  512.,  33.,   66.,
      99.,   132.,  170.,  204.,  238.,  272.,  315.,  350.,  385.,  420.,
      468.,  504.,  540.,  576.,  37.,   74.,   111.,  148.,  190.,  228.,
      266.,  304.,  351.,  390.,  429.,  468.,  520.,  560.,  600.,  640.,
      41.,   82.,   123.,  164.,  210.,  252.,  294.,  336.,  387.,  430.,
      473.,  516.,  572.,  616.,  660.,  704.,  45.,   90.,   135.,  180.,
      230.,  276.,  322.,  368.,  423.,  470.,  517.,  564.,  624.,  672.,
      720.,  768.,  49.,   98.,   147.,  196.,  250.,  300.,  350.,  400.,
      459.,  510.,  561.,  612.,  676.,  728.,  780.,  832.,  53.,   106.,
      159.,  212.,  270.,  324.,  378.,  432.,  495.,  550.,  605.,  660.,
      728.,  784.,  840.,  896.,  57.,   114.,  171.,  228.,  290.,  348.,
      406.,  464.,  531.,  590.,  649.,  708.,  780.,  840.,  900.,  960.,
      61.,   122.,  183.,  244.,  310.,  372.,  434.,  496.,  567.,  630.,
      693.,  756.,  832.,  896.,  960.,  1024., 65.,   130.,  195.,  260.,
      330.,  396.,  462.,  528.,  603.,  670.,  737.,  804.,  884.,  952.,
      1020., 1088., 69.,   138.,  207.,  276.,  350.,  420.,  490.,  560.,
      639.,  710.,  781.,  852.,  936.,  1008., 1080., 1152., 73.,   146.,
      219.,  292.,  370.,  444.,  518.,  592.,  675.,  750.,  825.,  900.,
      988.,  1064., 1140., 1216., 77.,   154.,  231.,  308.,  390.,  468.,
      546.,  624.,  711.,  790.,  869.,  948.,  1040., 1120., 1200., 1280.,
      81.,   162.,  243.,  324.,  410.,  492.,  574.,  656.,  747.,  830.,
      913.,  996.,  1092., 1176., 1260., 1344., 85.,   170.,  255.,  340.,
      430.,  516.,  602.,  688.,  783.,  870.,  957.,  1044., 1144., 1232.,
      1320., 1408., 89.,   178.,  267.,  356.,  450.,  540.,  630.,  720.,
      819.,  910.,  1001., 1092., 1196., 1288., 1380., 1472., 93.,   186.,
      279.,  372.,  470.,  564.,  658.,  752.,  855.,  950.,  1045., 1140.,
      1248., 1344., 1440., 1536., 97.,   194.,  291.,  388.,  490.,  588.,
      686.,  784.,  891.,  990.,  1089., 1188., 1300., 1400., 1500., 1600.,
      101.,  202.,  303.,  404.,  510.,  612.,  714.,  816.,  927.,  1030.,
      1133., 1236., 1352., 1456., 1560., 1664., 105.,  210.,  315.,  420.,
      530.,  636.,  742.,  848.,  963.,  1070., 1177., 1284., 1404., 1512.,
      1620., 1728.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12., 7.,  14., 8.,
      16., 9.,  18., 10., 20., 11., 22., 12., 24., 13., 26., 14., 28., 15., 30.,
      16., 32., 17., 34., 18., 36., 19., 38., 20., 40., 21., 42., 22., 44., 23.,
      46., 24., 48., 25., 50., 26., 52., 27., 54., 28., 56., 29., 58., 30., 60.,
      31., 62., 32., 64., 33., 66., 34., 68., 35., 70., 36., 72.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12., 7.,  14., 8.,
      16., 9.,  18., 10., 20., 11., 22., 12., 24., 13., 26., 14., 28., 15., 30.,
      16., 32., 17., 34., 18., 36., 19., 38., 20., 40., 21., 42., 22., 44., 23.,
      46., 24., 48., 25., 50., 26., 52., 27., 54., 28., 56., 29., 58., 30., 60.,
      31., 62., 32., 64., 33., 66., 34., 68., 35., 70., 36., 72.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   2.,  4.,  6.,   8.,   3.,  6.,  9.,   12.,
      4.,  8.,  12.,  16.,  5.,  10., 15.,  20.,  6.,  12., 18.,  24.,
      7.,  14., 21.,  28.,  8.,  16., 24.,  32.,  9.,  18., 27.,  36.,
      10., 20., 30.,  40.,  11., 22., 33.,  44.,  12., 24., 36.,  48.,
      13., 26., 39.,  52.,  14., 28., 42.,  56.,  15., 30., 45.,  60.,
      16., 32., 48.,  64.,  17., 34., 51.,  68.,  18., 36., 54.,  72.,
      19., 38., 57.,  76.,  20., 40., 60.,  80.,  21., 42., 63.,  84.,
      22., 44., 66.,  88.,  23., 46., 69.,  92.,  24., 48., 72.,  96.,
      25., 50., 75.,  100., 26., 52., 78.,  104., 27., 54., 81.,  108.,
      28., 56., 84.,  112., 29., 58., 87.,  116., 30., 60., 90.,  120.,
      31., 62., 93.,  124., 32., 64., 96.,  128., 33., 66., 99.,  132.,
      34., 68., 102., 136., 35., 70., 105., 140., 36., 72., 108., 144.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   2.,  4.,  6.,   8.,   3.,  6.,  9.,   12.,
      4.,  8.,  12.,  16.,  5.,  10., 15.,  20.,  6.,  12., 18.,  24.,
      7.,  14., 21.,  28.,  8.,  16., 24.,  32.,  9.,  18., 27.,  36.,
      10., 20., 30.,  40.,  11., 22., 33.,  44.,  12., 24., 36.,  48.,
      13., 26., 39.,  52.,  14., 28., 42.,  56.,  15., 30., 45.,  60.,
      16., 32., 48.,  64.,  17., 34., 51.,  68.,  18., 36., 54.,  72.,
      19., 38., 57.,  76.,  20., 40., 60.,  80.,  21., 42., 63.,  84.,
      22., 44., 66.,  88.,  23., 46., 69.,  92.,  24., 48., 72.,  96.,
      25., 50., 75.,  100., 26., 52., 78.,  104., 27., 54., 81.,  108.,
      28., 56., 84.,  112., 29., 58., 87.,  116., 30., 60., 90.,  120.,
      31., 62., 93.,  124., 32., 64., 96.,  128., 33., 66., 99.,  132.,
      34., 68., 102., 136., 35., 70., 105., 140., 36., 72., 108., 144.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,   3.,  8.,   5.,  12.,  7.,  16.,  9.,  20.,  11., 24.,
      13., 28.,  15., 32.,  17., 36.,  19., 40.,  21., 44.,  23., 48.,
      25., 52.,  27., 56.,  29., 60.,  31., 64.,  33., 68.,  35., 72.,
      37., 76.,  39., 80.,  41., 84.,  43., 88.,  45., 92.,  47., 96.,
      49., 100., 51., 104., 53., 108., 55., 112., 57., 116., 59., 120.,
      61., 124., 63., 128., 65., 132., 67., 136., 69., 140., 71., 144.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,   3.,  8.,   5.,  12.,  7.,  16.,  9.,  20.,  11., 24.,
      13., 28.,  15., 32.,  17., 36.,  19., 40.,  21., 44.,  23., 48.,
      25., 52.,  27., 56.,  29., 60.,  31., 64.,  33., 68.,  35., 72.,
      37., 76.,  39., 80.,  41., 84.,  43., 88.,  45., 92.,  47., 96.,
      49., 100., 51., 104., 53., 108., 55., 112., 57., 116., 59., 120.,
      61., 124., 63., 128., 65., 132., 67., 136., 69., 140., 71., 144.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,   6.,   8.,   3.,  6.,   12.,  16.,  5.,  10.,  18.,  24.,
      7.,  14.,  24.,  32.,  9.,  18.,  30.,  40.,  11., 22.,  36.,  48.,
      13., 26.,  42.,  56.,  15., 30.,  48.,  64.,  17., 34.,  54.,  72.,
      19., 38.,  60.,  80.,  21., 42.,  66.,  88.,  23., 46.,  72.,  96.,
      25., 50.,  78.,  104., 27., 54.,  84.,  112., 29., 58.,  90.,  120.,
      31., 62.,  96.,  128., 33., 66.,  102., 136., 35., 70.,  108., 144.,
      37., 74.,  114., 152., 39., 78.,  120., 160., 41., 82.,  126., 168.,
      43., 86.,  132., 176., 45., 90.,  138., 184., 47., 94.,  144., 192.,
      49., 98.,  150., 200., 51., 102., 156., 208., 53., 106., 162., 216.,
      55., 110., 168., 224., 57., 114., 174., 232., 59., 118., 180., 240.,
      61., 122., 186., 248., 63., 126., 192., 256., 65., 130., 198., 264.,
      67., 134., 204., 272., 69., 138., 210., 280., 71., 142., 216., 288.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,   6.,   8.,   3.,  6.,   12.,  16.,  5.,  10.,  18.,  24.,
      7.,  14.,  24.,  32.,  9.,  18.,  30.,  40.,  11., 22.,  36.,  48.,
      13., 26.,  42.,  56.,  15., 30.,  48.,  64.,  17., 34.,  54.,  72.,
      19., 38.,  60.,  80.,  21., 42.,  66.,  88.,  23., 46.,  72.,  96.,
      25., 50.,  78.,  104., 27., 54.,  84.,  112., 29., 58.,  90.,  120.,
      31., 62.,  96.,  128., 33., 66.,  102., 136., 35., 70.,  108., 144.,
      37., 74.,  114., 152., 39., 78.,  120., 160., 41., 82.,  126., 168.,
      43., 86.,  132., 176., 45., 90.,  138., 184., 47., 94.,  144., 192.,
      49., 98.,  150., 200., 51., 102., 156., 208., 53., 106., 162., 216.,
      55., 110., 168., 224., 57., 114., 174., 232., 59., 118., 180., 240.,
      61., 122., 186., 248., 63., 126., 192., 256., 65., 130., 198., 264.,
      67., 134., 204., 272., 69., 138., 210., 280., 71., 142., 216., 288.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  3.,   6.,   9.,   12.,
      20.,  24.,  28.,  32.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      7.,   14.,  21.,  28.,  40.,  48.,  56.,  64.,  9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  11.,  22.,  33.,  44.,  60.,  72.,  84.,  96.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 15.,  30.,  45.,  60.,
      80.,  96.,  112., 128., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      19.,  38.,  57.,  76.,  100., 120., 140., 160., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 23.,  46.,  69.,  92.,  120., 144., 168., 192.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 27.,  54.,  81.,  108.,
      140., 168., 196., 224., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      31.,  62.,  93.,  124., 160., 192., 224., 256., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 35.,  70.,  105., 140., 180., 216., 252., 288.,
      37.,  74.,  111., 148., 190., 228., 266., 304., 39.,  78.,  117., 156.,
      200., 240., 280., 320., 41.,  82.,  123., 164., 210., 252., 294., 336.,
      43.,  86.,  129., 172., 220., 264., 308., 352., 45.,  90.,  135., 180.,
      230., 276., 322., 368., 47.,  94.,  141., 188., 240., 288., 336., 384.,
      49.,  98.,  147., 196., 250., 300., 350., 400., 51.,  102., 153., 204.,
      260., 312., 364., 416., 53.,  106., 159., 212., 270., 324., 378., 432.,
      55.,  110., 165., 220., 280., 336., 392., 448., 57.,  114., 171., 228.,
      290., 348., 406., 464., 59.,  118., 177., 236., 300., 360., 420., 480.,
      61.,  122., 183., 244., 310., 372., 434., 496., 63.,  126., 189., 252.,
      320., 384., 448., 512., 65.,  130., 195., 260., 330., 396., 462., 528.,
      67.,  134., 201., 268., 340., 408., 476., 544., 69.,  138., 207., 276.,
      350., 420., 490., 560., 71.,  142., 213., 284., 360., 432., 504., 576.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  3.,   6.,   9.,   12.,
      20.,  24.,  28.,  32.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      7.,   14.,  21.,  28.,  40.,  48.,  56.,  64.,  9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  11.,  22.,  33.,  44.,  60.,  72.,  84.,  96.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 15.,  30.,  45.,  60.,
      80.,  96.,  112., 128., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      19.,  38.,  57.,  76.,  100., 120., 140., 160., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 23.,  46.,  69.,  92.,  120., 144., 168., 192.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 27.,  54.,  81.,  108.,
      140., 168., 196., 224., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      31.,  62.,  93.,  124., 160., 192., 224., 256., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 35.,  70.,  105., 140., 180., 216., 252., 288.,
      37.,  74.,  111., 148., 190., 228., 266., 304., 39.,  78.,  117., 156.,
      200., 240., 280., 320., 41.,  82.,  123., 164., 210., 252., 294., 336.,
      43.,  86.,  129., 172., 220., 264., 308., 352., 45.,  90.,  135., 180.,
      230., 276., 322., 368., 47.,  94.,  141., 188., 240., 288., 336., 384.,
      49.,  98.,  147., 196., 250., 300., 350., 400., 51.,  102., 153., 204.,
      260., 312., 364., 416., 53.,  106., 159., 212., 270., 324., 378., 432.,
      55.,  110., 165., 220., 280., 336., 392., 448., 57.,  114., 171., 228.,
      290., 348., 406., 464., 59.,  118., 177., 236., 300., 360., 420., 480.,
      61.,  122., 183., 244., 310., 372., 434., 496., 63.,  126., 189., 252.,
      320., 384., 448., 512., 65.,  130., 195., 260., 330., 396., 462., 528.,
      67.,  134., 201., 268., 340., 408., 476., 544., 69.,  138., 207., 276.,
      350., 420., 490., 560., 71.,  142., 213., 284., 360., 432., 504., 576.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   9.,   16.,  5.,   12.,  21.,  32.,  9.,   20.,  33.,  48.,
      13.,  28.,  45.,  64.,  17.,  36.,  57.,  80.,  21.,  44.,  69.,  96.,
      25.,  52.,  81.,  112., 29.,  60.,  93.,  128., 33.,  68.,  105., 144.,
      37.,  76.,  117., 160., 41.,  84.,  129., 176., 45.,  92.,  141., 192.,
      49.,  100., 153., 208., 53.,  108., 165., 224., 57.,  116., 177., 240.,
      61.,  124., 189., 256., 65.,  132., 201., 272., 69.,  140., 213., 288.,
      73.,  148., 225., 304., 77.,  156., 237., 320., 81.,  164., 249., 336.,
      85.,  172., 261., 352., 89.,  180., 273., 368., 93.,  188., 285., 384.,
      97.,  196., 297., 400., 101., 204., 309., 416., 105., 212., 321., 432.,
      109., 220., 333., 448., 113., 228., 345., 464., 117., 236., 357., 480.,
      121., 244., 369., 496., 125., 252., 381., 512., 129., 260., 393., 528.,
      133., 268., 405., 544., 137., 276., 417., 560., 141., 284., 429., 576.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   9.,   16.,  5.,   12.,  21.,  32.,  9.,   20.,  33.,  48.,
      13.,  28.,  45.,  64.,  17.,  36.,  57.,  80.,  21.,  44.,  69.,  96.,
      25.,  52.,  81.,  112., 29.,  60.,  93.,  128., 33.,  68.,  105., 144.,
      37.,  76.,  117., 160., 41.,  84.,  129., 176., 45.,  92.,  141., 192.,
      49.,  100., 153., 208., 53.,  108., 165., 224., 57.,  116., 177., 240.,
      61.,  124., 189., 256., 65.,  132., 201., 272., 69.,  140., 213., 288.,
      73.,  148., 225., 304., 77.,  156., 237., 320., 81.,  164., 249., 336.,
      85.,  172., 261., 352., 89.,  180., 273., 368., 93.,  188., 285., 384.,
      97.,  196., 297., 400., 101., 204., 309., 416., 105., 212., 321., 432.,
      109., 220., 333., 448., 113., 228., 345., 464., 117., 236., 357., 480.,
      121., 244., 369., 496., 125., 252., 381., 512., 129., 260., 393., 528.,
      133., 268., 405., 544., 137., 276., 417., 560., 141., 284., 429., 576.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,   6.,    8.,   15.,   18.,  28.,  32.,   5.,   10.,  18.,
      24.,   35.,  42.,   56.,  64.,   9.,   18.,  30.,   40.,  55.,  66.,
      84.,   96.,  13.,   26.,  42.,   56.,  75.,  90.,   112., 128., 17.,
      34.,   54.,  72.,   95.,  114.,  140., 160., 21.,   42.,  66.,  88.,
      115.,  138., 168.,  192., 25.,   50.,  78.,  104.,  135., 162., 196.,
      224.,  29.,  58.,   90.,  120.,  155., 186., 224.,  256., 33.,  66.,
      102.,  136., 175.,  210., 252.,  288., 37.,  74.,   114., 152., 195.,
      234.,  280., 320.,  41.,  82.,   126., 168., 215.,  258., 308., 352.,
      45.,   90.,  138.,  184., 235.,  282., 336., 384.,  49.,  98.,  150.,
      200.,  255., 306.,  364., 416.,  53.,  106., 162.,  216., 275., 330.,
      392.,  448., 57.,   114., 174.,  232., 295., 354.,  420., 480., 61.,
      122.,  186., 248.,  315., 378.,  448., 512., 65.,   130., 198., 264.,
      335.,  402., 476.,  544., 69.,   138., 210., 280.,  355., 426., 504.,
      576.,  73.,  146.,  222., 296.,  375., 450., 532.,  608., 77.,  154.,
      234.,  312., 395.,  474., 560.,  640., 81.,  162.,  246., 328., 415.,
      498.,  588., 672.,  85.,  170.,  258., 344., 435.,  522., 616., 704.,
      89.,   178., 270.,  360., 455.,  546., 644., 736.,  93.,  186., 282.,
      376.,  475., 570.,  672., 768.,  97.,  194., 294.,  392., 495., 594.,
      700.,  800., 101.,  202., 306.,  408., 515., 618.,  728., 832., 105.,
      210.,  318., 424.,  535., 642.,  756., 864., 109.,  218., 330., 440.,
      555.,  666., 784.,  896., 113.,  226., 342., 456.,  575., 690., 812.,
      928.,  117., 234.,  354., 472.,  595., 714., 840.,  960., 121., 242.,
      366.,  488., 615.,  738., 868.,  992., 125., 250.,  378., 504., 635.,
      762.,  896., 1024., 129., 258.,  390., 520., 655.,  786., 924., 1056.,
      133.,  266., 402.,  536., 675.,  810., 952., 1088., 137., 274., 414.,
      552.,  695., 834.,  980., 1120., 141., 282., 426.,  568., 715., 858.,
      1008., 1152.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,   6.,    8.,   15.,   18.,  28.,  32.,   5.,   10.,  18.,
      24.,   35.,  42.,   56.,  64.,   9.,   18.,  30.,   40.,  55.,  66.,
      84.,   96.,  13.,   26.,  42.,   56.,  75.,  90.,   112., 128., 17.,
      34.,   54.,  72.,   95.,  114.,  140., 160., 21.,   42.,  66.,  88.,
      115.,  138., 168.,  192., 25.,   50.,  78.,  104.,  135., 162., 196.,
      224.,  29.,  58.,   90.,  120.,  155., 186., 224.,  256., 33.,  66.,
      102.,  136., 175.,  210., 252.,  288., 37.,  74.,   114., 152., 195.,
      234.,  280., 320.,  41.,  82.,   126., 168., 215.,  258., 308., 352.,
      45.,   90.,  138.,  184., 235.,  282., 336., 384.,  49.,  98.,  150.,
      200.,  255., 306.,  364., 416.,  53.,  106., 162.,  216., 275., 330.,
      392.,  448., 57.,   114., 174.,  232., 295., 354.,  420., 480., 61.,
      122.,  186., 248.,  315., 378.,  448., 512., 65.,   130., 198., 264.,
      335.,  402., 476.,  544., 69.,   138., 210., 280.,  355., 426., 504.,
      576.,  73.,  146.,  222., 296.,  375., 450., 532.,  608., 77.,  154.,
      234.,  312., 395.,  474., 560.,  640., 81.,  162.,  246., 328., 415.,
      498.,  588., 672.,  85.,  170.,  258., 344., 435.,  522., 616., 704.,
      89.,   178., 270.,  360., 455.,  546., 644., 736.,  93.,  186., 282.,
      376.,  475., 570.,  672., 768.,  97.,  194., 294.,  392., 495., 594.,
      700.,  800., 101.,  202., 306.,  408., 515., 618.,  728., 832., 105.,
      210.,  318., 424.,  535., 642.,  756., 864., 109.,  218., 330., 440.,
      555.,  666., 784.,  896., 113.,  226., 342., 456.,  575., 690., 812.,
      928.,  117., 234.,  354., 472.,  595., 714., 840.,  960., 121., 242.,
      366.,  488., 615.,  738., 868.,  992., 125., 250.,  378., 504., 635.,
      762.,  896., 1024., 129., 258.,  390., 520., 655.,  786., 924., 1056.,
      133.,  266., 402.,  536., 675.,  810., 952., 1088., 137., 274., 414.,
      552.,  695., 834.,  980., 1120., 141., 282., 426.,  568., 715., 858.,
      1008., 1152.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    3.,    4.,    10.,   12.,   14.,   16.,   27.,   30.,
      33.,   36.,   52.,   56.,   60.,   64.,   5.,    10.,   15.,   20.,
      30.,   36.,   42.,   48.,   63.,   70.,   77.,   84.,   104.,  112.,
      120.,  128.,  9.,    18.,   27.,   36.,   50.,   60.,   70.,   80.,
      99.,   110.,  121.,  132.,  156.,  168.,  180.,  192.,  13.,   26.,
      39.,   52.,   70.,   84.,   98.,   112.,  135.,  150.,  165.,  180.,
      208.,  224.,  240.,  256.,  17.,   34.,   51.,   68.,   90.,   108.,
      126.,  144.,  171.,  190.,  209.,  228.,  260.,  280.,  300.,  320.,
      21.,   42.,   63.,   84.,   110.,  132.,  154.,  176.,  207.,  230.,
      253.,  276.,  312.,  336.,  360.,  384.,  25.,   50.,   75.,   100.,
      130.,  156.,  182.,  208.,  243.,  270.,  297.,  324.,  364.,  392.,
      420.,  448.,  29.,   58.,   87.,   116.,  150.,  180.,  210.,  240.,
      279.,  310.,  341.,  372.,  416.,  448.,  480.,  512.,  33.,   66.,
      99.,   132.,  170.,  204.,  238.,  272.,  315.,  350.,  385.,  420.,
      468.,  504.,  540.,  576.,  37.,   74.,   111.,  148.,  190.,  228.,
      266.,  304.,  351.,  390.,  429.,  468.,  520.,  560.,  600.,  640.,
      41.,   82.,   123.,  164.,  210.,  252.,  294.,  336.,  387.,  430.,
      473.,  516.,  572.,  616.,  660.,  704.,  45.,   90.,   135.,  180.,
      230.,  276.,  322.,  368.,  423.,  470.,  517.,  564.,  624.,  672.,
      720.,  768.,  49.,   98.,   147.,  196.,  250.,  300.,  350.,  400.,
      459.,  510.,  561.,  612.,  676.,  728.,  780.,  832.,  53.,   106.,
      159.,  212.,  270.,  324.,  378.,  432.,  495.,  550.,  605.,  660.,
      728.,  784.,  840.,  896.,  57.,   114.,  171.,  228.,  290.,  348.,
      406.,  464.,  531.,  590.,  649.,  708.,  780.,  840.,  900.,  960.,
      61.,   122.,  183.,  244.,  310.,  372.,  434.,  496.,  567.,  630.,
      693.,  756.,  832.,  896.,  960.,  1024., 65.,   130.,  195.,  260.,
      330.,  396.,  462.,  528.,  603.,  670.,  737.,  804.,  884.,  952.,
      1020., 1088., 69.,   138.,  207.,  276.,  350.,  420.,  490.,  560.,
      639.,  710.,  781.,  852.,  936.,  1008., 1080., 1152., 73.,   146.,
      219.,  292.,  370.,  444.,  518.,  592.,  675.,  750.,  825.,  900.,
      988.,  1064., 1140., 1216., 77.,   154.,  231.,  308.,  390.,  468.,
      546.,  624.,  711.,  790.,  869.,  948.,  1040., 1120., 1200., 1280.,
      81.,   162.,  243.,  324.,  410.,  492.,  574.,  656.,  747.,  830.,
      913.,  996.,  1092., 1176., 1260., 1344., 85.,   170.,  255.,  340.,
      430.,  516.,  602.,  688.,  783.,  870.,  957.,  1044., 1144., 1232.,
      1320., 1408., 89.,   178.,  267.,  356.,  450.,  540.,  630.,  720.,
      819.,  910.,  1001., 1092., 1196., 1288., 1380., 1472., 93.,   186.,
      279.,  372.,  470.,  564.,  658.,  752.,  855.,  950.,  1045., 1140.,
      1248., 1344., 1440., 1536., 97.,   194.,  291.,  388.,  490.,  588.,
      686.,  784.,  891.,  990.,  1089., 1188., 1300., 1400., 1500., 1600.,
      101.,  202.,  303.,  404.,  510.,  612.,  714.,  816.,  927.,  1030.,
      1133., 1236., 1352., 1456., 1560., 1664., 105.,  210.,  315.,  420.,
      530.,  636.,  742.,  848.,  963.,  1070., 1177., 1284., 1404., 1512.,
      1620., 1728., 109.,  218.,  327.,  436.,  550.,  660.,  770.,  880.,
      999.,  1110., 1221., 1332., 1456., 1568., 1680., 1792., 113.,  226.,
      339.,  452.,  570.,  684.,  798.,  912.,  1035., 1150., 1265., 1380.,
      1508., 1624., 1740., 1856., 117.,  234.,  351.,  468.,  590.,  708.,
      826.,  944.,  1071., 1190., 1309., 1428., 1560., 1680., 1800., 1920.,
      121.,  242.,  363.,  484.,  610.,  732.,  854.,  976.,  1107., 1230.,
      1353., 1476., 1612., 1736., 1860., 1984., 125.,  250.,  375.,  500.,
      630.,  756.,  882.,  1008., 1143., 1270., 1397., 1524., 1664., 1792.,
      1920., 2048., 129.,  258.,  387.,  516.,  650.,  780.,  910.,  1040.,
      1179., 1310., 1441., 1572., 1716., 1848., 1980., 2112., 133.,  266.,
      399.,  532.,  670.,  804.,  938.,  1072., 1215., 1350., 1485., 1620.,
      1768., 1904., 2040., 2176., 137.,  274.,  411.,  548.,  690.,  828.,
      966.,  1104., 1251., 1390., 1529., 1668., 1820., 1960., 2100., 2240.,
      141.,  282.,  423.,  564.,  710.,  852.,  994.,  1136., 1287., 1430.,
      1573., 1716., 1872., 2016., 2160., 2304.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    3.,    4.,    10.,   12.,   14.,   16.,   27.,   30.,
      33.,   36.,   52.,   56.,   60.,   64.,   5.,    10.,   15.,   20.,
      30.,   36.,   42.,   48.,   63.,   70.,   77.,   84.,   104.,  112.,
      120.,  128.,  9.,    18.,   27.,   36.,   50.,   60.,   70.,   80.,
      99.,   110.,  121.,  132.,  156.,  168.,  180.,  192.,  13.,   26.,
      39.,   52.,   70.,   84.,   98.,   112.,  135.,  150.,  165.,  180.,
      208.,  224.,  240.,  256.,  17.,   34.,   51.,   68.,   90.,   108.,
      126.,  144.,  171.,  190.,  209.,  228.,  260.,  280.,  300.,  320.,
      21.,   42.,   63.,   84.,   110.,  132.,  154.,  176.,  207.,  230.,
      253.,  276.,  312.,  336.,  360.,  384.,  25.,   50.,   75.,   100.,
      130.,  156.,  182.,  208.,  243.,  270.,  297.,  324.,  364.,  392.,
      420.,  448.,  29.,   58.,   87.,   116.,  150.,  180.,  210.,  240.,
      279.,  310.,  341.,  372.,  416.,  448.,  480.,  512.,  33.,   66.,
      99.,   132.,  170.,  204.,  238.,  272.,  315.,  350.,  385.,  420.,
      468.,  504.,  540.,  576.,  37.,   74.,   111.,  148.,  190.,  228.,
      266.,  304.,  351.,  390.,  429.,  468.,  520.,  560.,  600.,  640.,
      41.,   82.,   123.,  164.,  210.,  252.,  294.,  336.,  387.,  430.,
      473.,  516.,  572.,  616.,  660.,  704.,  45.,   90.,   135.,  180.,
      230.,  276.,  322.,  368.,  423.,  470.,  517.,  564.,  624.,  672.,
      720.,  768.,  49.,   98.,   147.,  196.,  250.,  300.,  350.,  400.,
      459.,  510.,  561.,  612.,  676.,  728.,  780.,  832.,  53.,   106.,
      159.,  212.,  270.,  324.,  378.,  432.,  495.,  550.,  605.,  660.,
      728.,  784.,  840.,  896.,  57.,   114.,  171.,  228.,  290.,  348.,
      406.,  464.,  531.,  590.,  649.,  708.,  780.,  840.,  900.,  960.,
      61.,   122.,  183.,  244.,  310.,  372.,  434.,  496.,  567.,  630.,
      693.,  756.,  832.,  896.,  960.,  1024., 65.,   130.,  195.,  260.,
      330.,  396.,  462.,  528.,  603.,  670.,  737.,  804.,  884.,  952.,
      1020., 1088., 69.,   138.,  207.,  276.,  350.,  420.,  490.,  560.,
      639.,  710.,  781.,  852.,  936.,  1008., 1080., 1152., 73.,   146.,
      219.,  292.,  370.,  444.,  518.,  592.,  675.,  750.,  825.,  900.,
      988.,  1064., 1140., 1216., 77.,   154.,  231.,  308.,  390.,  468.,
      546.,  624.,  711.,  790.,  869.,  948.,  1040., 1120., 1200., 1280.,
      81.,   162.,  243.,  324.,  410.,  492.,  574.,  656.,  747.,  830.,
      913.,  996.,  1092., 1176., 1260., 1344., 85.,   170.,  255.,  340.,
      430.,  516.,  602.,  688.,  783.,  870.,  957.,  1044., 1144., 1232.,
      1320., 1408., 89.,   178.,  267.,  356.,  450.,  540.,  630.,  720.,
      819.,  910.,  1001., 1092., 1196., 1288., 1380., 1472., 93.,   186.,
      279.,  372.,  470.,  564.,  658.,  752.,  855.,  950.,  1045., 1140.,
      1248., 1344., 1440., 1536., 97.,   194.,  291.,  388.,  490.,  588.,
      686.,  784.,  891.,  990.,  1089., 1188., 1300., 1400., 1500., 1600.,
      101.,  202.,  303.,  404.,  510.,  612.,  714.,  816.,  927.,  1030.,
      1133., 1236., 1352., 1456., 1560., 1664., 105.,  210.,  315.,  420.,
      530.,  636.,  742.,  848.,  963.,  1070., 1177., 1284., 1404., 1512.,
      1620., 1728., 109.,  218.,  327.,  436.,  550.,  660.,  770.,  880.,
      999.,  1110., 1221., 1332., 1456., 1568., 1680., 1792., 113.,  226.,
      339.,  452.,  570.,  684.,  798.,  912.,  1035., 1150., 1265., 1380.,
      1508., 1624., 1740., 1856., 117.,  234.,  351.,  468.,  590.,  708.,
      826.,  944.,  1071., 1190., 1309., 1428., 1560., 1680., 1800., 1920.,
      121.,  242.,  363.,  484.,  610.,  732.,  854.,  976.,  1107., 1230.,
      1353., 1476., 1612., 1736., 1860., 1984., 125.,  250.,  375.,  500.,
      630.,  756.,  882.,  1008., 1143., 1270., 1397., 1524., 1664., 1792.,
      1920., 2048., 129.,  258.,  387.,  516.,  650.,  780.,  910.,  1040.,
      1179., 1310., 1441., 1572., 1716., 1848., 1980., 2112., 133.,  266.,
      399.,  532.,  670.,  804.,  938.,  1072., 1215., 1350., 1485., 1620.,
      1768., 1904., 2040., 2176., 137.,  274.,  411.,  548.,  690.,  828.,
      966.,  1104., 1251., 1390., 1529., 1668., 1820., 1960., 2100., 2240.,
      141.,  282.,  423.,  564.,  710.,  852.,  994.,  1136., 1287., 1430.,
      1573., 1716., 1872., 2016., 2160., 2304.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12.,
      7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24.,
      13., 26., 14., 28., 15., 30., 16., 32., 17., 34., 18., 36.,
      19., 38., 20., 40., 21., 42., 22., 44., 23., 46., 24., 48.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12.,
      7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24.,
      13., 26., 14., 28., 15., 30., 16., 32., 17., 34., 18., 36.,
      19., 38., 20., 40., 21., 42., 22., 44., 23., 46., 24., 48.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,
      12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14., 21., 28.,
      8.,  16., 24., 32., 9.,  18., 27., 36., 10., 20., 30., 40., 11., 22.,
      33., 44., 12., 24., 36., 48., 13., 26., 39., 52., 14., 28., 42., 56.,
      15., 30., 45., 60., 16., 32., 48., 64., 17., 34., 51., 68., 18., 36.,
      54., 72., 19., 38., 57., 76., 20., 40., 60., 80., 21., 42., 63., 84.,
      22., 44., 66., 88., 23., 46., 69., 92., 24., 48., 72., 96.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,
      12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14., 21., 28.,
      8.,  16., 24., 32., 9.,  18., 27., 36., 10., 20., 30., 40., 11., 22.,
      33., 44., 12., 24., 36., 48., 13., 26., 39., 52., 14., 28., 42., 56.,
      15., 30., 45., 60., 16., 32., 48., 64., 17., 34., 51., 68., 18., 36.,
      54., 72., 19., 38., 57., 76., 20., 40., 60., 80., 21., 42., 63., 84.,
      22., 44., 66., 88., 23., 46., 69., 92., 24., 48., 72., 96.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  3.,  8.,  5.,  12., 7.,  16., 9.,  20., 11., 24.,
      13., 28., 15., 32., 17., 36., 19., 40., 21., 44., 23., 48.,
      25., 52., 27., 56., 29., 60., 31., 64., 33., 68., 35., 72.,
      37., 76., 39., 80., 41., 84., 43., 88., 45., 92., 47., 96.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  3.,  8.,  5.,  12., 7.,  16., 9.,  20., 11., 24.,
      13., 28., 15., 32., 17., 36., 19., 40., 21., 44., 23., 48.,
      25., 52., 27., 56., 29., 60., 31., 64., 33., 68., 35., 72.,
      37., 76., 39., 80., 41., 84., 43., 88., 45., 92., 47., 96.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,   8.,   3.,  6.,  12.,  16.,  5.,  10., 18.,  24.,
      7.,  14., 24.,  32.,  9.,  18., 30.,  40.,  11., 22., 36.,  48.,
      13., 26., 42.,  56.,  15., 30., 48.,  64.,  17., 34., 54.,  72.,
      19., 38., 60.,  80.,  21., 42., 66.,  88.,  23., 46., 72.,  96.,
      25., 50., 78.,  104., 27., 54., 84.,  112., 29., 58., 90.,  120.,
      31., 62., 96.,  128., 33., 66., 102., 136., 35., 70., 108., 144.,
      37., 74., 114., 152., 39., 78., 120., 160., 41., 82., 126., 168.,
      43., 86., 132., 176., 45., 90., 138., 184., 47., 94., 144., 192.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  6.,   8.,   3.,  6.,  12.,  16.,  5.,  10., 18.,  24.,
      7.,  14., 24.,  32.,  9.,  18., 30.,  40.,  11., 22., 36.,  48.,
      13., 26., 42.,  56.,  15., 30., 48.,  64.,  17., 34., 54.,  72.,
      19., 38., 60.,  80.,  21., 42., 66.,  88.,  23., 46., 72.,  96.,
      25., 50., 78.,  104., 27., 54., 84.,  112., 29., 58., 90.,  120.,
      31., 62., 96.,  128., 33., 66., 102., 136., 35., 70., 108., 144.,
      37., 74., 114., 152., 39., 78., 120., 160., 41., 82., 126., 168.,
      43., 86., 132., 176., 45., 90., 138., 184., 47., 94., 144., 192.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  3.,   6.,   9.,   12.,
      20.,  24.,  28.,  32.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      7.,   14.,  21.,  28.,  40.,  48.,  56.,  64.,  9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  11.,  22.,  33.,  44.,  60.,  72.,  84.,  96.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 15.,  30.,  45.,  60.,
      80.,  96.,  112., 128., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      19.,  38.,  57.,  76.,  100., 120., 140., 160., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 23.,  46.,  69.,  92.,  120., 144., 168., 192.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 27.,  54.,  81.,  108.,
      140., 168., 196., 224., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      31.,  62.,  93.,  124., 160., 192., 224., 256., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 35.,  70.,  105., 140., 180., 216., 252., 288.,
      37.,  74.,  111., 148., 190., 228., 266., 304., 39.,  78.,  117., 156.,
      200., 240., 280., 320., 41.,  82.,  123., 164., 210., 252., 294., 336.,
      43.,  86.,  129., 172., 220., 264., 308., 352., 45.,  90.,  135., 180.,
      230., 276., 322., 368., 47.,  94.,  141., 188., 240., 288., 336., 384.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  3.,   6.,   9.,   12.,
      20.,  24.,  28.,  32.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      7.,   14.,  21.,  28.,  40.,  48.,  56.,  64.,  9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  11.,  22.,  33.,  44.,  60.,  72.,  84.,  96.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 15.,  30.,  45.,  60.,
      80.,  96.,  112., 128., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      19.,  38.,  57.,  76.,  100., 120., 140., 160., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 23.,  46.,  69.,  92.,  120., 144., 168., 192.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 27.,  54.,  81.,  108.,
      140., 168., 196., 224., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      31.,  62.,  93.,  124., 160., 192., 224., 256., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 35.,  70.,  105., 140., 180., 216., 252., 288.,
      37.,  74.,  111., 148., 190., 228., 266., 304., 39.,  78.,  117., 156.,
      200., 240., 280., 320., 41.,  82.,  123., 164., 210., 252., 294., 336.,
      43.,  86.,  129., 172., 220., 264., 308., 352., 45.,  90.,  135., 180.,
      230., 276., 322., 368., 47.,  94.,  141., 188., 240., 288., 336., 384.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,   9.,   16.,  5.,  12.,  21.,  32.,  9.,  20.,  33.,  48.,
      13., 28.,  45.,  64.,  17., 36.,  57.,  80.,  21., 44.,  69.,  96.,
      25., 52.,  81.,  112., 29., 60.,  93.,  128., 33., 68.,  105., 144.,
      37., 76.,  117., 160., 41., 84.,  129., 176., 45., 92.,  141., 192.,
      49., 100., 153., 208., 53., 108., 165., 224., 57., 116., 177., 240.,
      61., 124., 189., 256., 65., 132., 201., 272., 69., 140., 213., 288.,
      73., 148., 225., 304., 77., 156., 237., 320., 81., 164., 249., 336.,
      85., 172., 261., 352., 89., 180., 273., 368., 93., 188., 285., 384.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,   9.,   16.,  5.,  12.,  21.,  32.,  9.,  20.,  33.,  48.,
      13., 28.,  45.,  64.,  17., 36.,  57.,  80.,  21., 44.,  69.,  96.,
      25., 52.,  81.,  112., 29., 60.,  93.,  128., 33., 68.,  105., 144.,
      37., 76.,  117., 160., 41., 84.,  129., 176., 45., 92.,  141., 192.,
      49., 100., 153., 208., 53., 108., 165., 224., 57., 116., 177., 240.,
      61., 124., 189., 256., 65., 132., 201., 272., 69., 140., 213., 288.,
      73., 148., 225., 304., 77., 156., 237., 320., 81., 164., 249., 336.,
      85., 172., 261., 352., 89., 180., 273., 368., 93., 188., 285., 384.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   6.,   8.,   15.,  18.,  28.,  32.,  5.,   10.,  18.,  24.,
      35.,  42.,  56.,  64.,  9.,   18.,  30.,  40.,  55.,  66.,  84.,  96.,
      13.,  26.,  42.,  56.,  75.,  90.,  112., 128., 17.,  34.,  54.,  72.,
      95.,  114., 140., 160., 21.,  42.,  66.,  88.,  115., 138., 168., 192.,
      25.,  50.,  78.,  104., 135., 162., 196., 224., 29.,  58.,  90.,  120.,
      155., 186., 224., 256., 33.,  66.,  102., 136., 175., 210., 252., 288.,
      37.,  74.,  114., 152., 195., 234., 280., 320., 41.,  82.,  126., 168.,
      215., 258., 308., 352., 45.,  90.,  138., 184., 235., 282., 336., 384.,
      49.,  98.,  150., 200., 255., 306., 364., 416., 53.,  106., 162., 216.,
      275., 330., 392., 448., 57.,  114., 174., 232., 295., 354., 420., 480.,
      61.,  122., 186., 248., 315., 378., 448., 512., 65.,  130., 198., 264.,
      335., 402., 476., 544., 69.,  138., 210., 280., 355., 426., 504., 576.,
      73.,  146., 222., 296., 375., 450., 532., 608., 77.,  154., 234., 312.,
      395., 474., 560., 640., 81.,  162., 246., 328., 415., 498., 588., 672.,
      85.,  170., 258., 344., 435., 522., 616., 704., 89.,  178., 270., 360.,
      455., 546., 644., 736., 93.,  186., 282., 376., 475., 570., 672., 768.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   6.,   8.,   15.,  18.,  28.,  32.,  5.,   10.,  18.,  24.,
      35.,  42.,  56.,  64.,  9.,   18.,  30.,  40.,  55.,  66.,  84.,  96.,
      13.,  26.,  42.,  56.,  75.,  90.,  112., 128., 17.,  34.,  54.,  72.,
      95.,  114., 140., 160., 21.,  42.,  66.,  88.,  115., 138., 168., 192.,
      25.,  50.,  78.,  104., 135., 162., 196., 224., 29.,  58.,  90.,  120.,
      155., 186., 224., 256., 33.,  66.,  102., 136., 175., 210., 252., 288.,
      37.,  74.,  114., 152., 195., 234., 280., 320., 41.,  82.,  126., 168.,
      215., 258., 308., 352., 45.,  90.,  138., 184., 235., 282., 336., 384.,
      49.,  98.,  150., 200., 255., 306., 364., 416., 53.,  106., 162., 216.,
      275., 330., 392., 448., 57.,  114., 174., 232., 295., 354., 420., 480.,
      61.,  122., 186., 248., 315., 378., 448., 512., 65.,  130., 198., 264.,
      335., 402., 476., 544., 69.,  138., 210., 280., 355., 426., 504., 576.,
      73.,  146., 222., 296., 375., 450., 532., 608., 77.,  154., 234., 312.,
      395., 474., 560., 640., 81.,  162., 246., 328., 415., 498., 588., 672.,
      85.,  170., 258., 344., 435., 522., 616., 704., 89.,  178., 270., 360.,
      455., 546., 644., 736., 93.,  186., 282., 376., 475., 570., 672., 768.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    3.,    4.,    10.,   12.,   14.,   16.,   27.,   30.,
      33.,   36.,   52.,   56.,   60.,   64.,   5.,    10.,   15.,   20.,
      30.,   36.,   42.,   48.,   63.,   70.,   77.,   84.,   104.,  112.,
      120.,  128.,  9.,    18.,   27.,   36.,   50.,   60.,   70.,   80.,
      99.,   110.,  121.,  132.,  156.,  168.,  180.,  192.,  13.,   26.,
      39.,   52.,   70.,   84.,   98.,   112.,  135.,  150.,  165.,  180.,
      208.,  224.,  240.,  256.,  17.,   34.,   51.,   68.,   90.,   108.,
      126.,  144.,  171.,  190.,  209.,  228.,  260.,  280.,  300.,  320.,
      21.,   42.,   63.,   84.,   110.,  132.,  154.,  176.,  207.,  230.,
      253.,  276.,  312.,  336.,  360.,  384.,  25.,   50.,   75.,   100.,
      130.,  156.,  182.,  208.,  243.,  270.,  297.,  324.,  364.,  392.,
      420.,  448.,  29.,   58.,   87.,   116.,  150.,  180.,  210.,  240.,
      279.,  310.,  341.,  372.,  416.,  448.,  480.,  512.,  33.,   66.,
      99.,   132.,  170.,  204.,  238.,  272.,  315.,  350.,  385.,  420.,
      468.,  504.,  540.,  576.,  37.,   74.,   111.,  148.,  190.,  228.,
      266.,  304.,  351.,  390.,  429.,  468.,  520.,  560.,  600.,  640.,
      41.,   82.,   123.,  164.,  210.,  252.,  294.,  336.,  387.,  430.,
      473.,  516.,  572.,  616.,  660.,  704.,  45.,   90.,   135.,  180.,
      230.,  276.,  322.,  368.,  423.,  470.,  517.,  564.,  624.,  672.,
      720.,  768.,  49.,   98.,   147.,  196.,  250.,  300.,  350.,  400.,
      459.,  510.,  561.,  612.,  676.,  728.,  780.,  832.,  53.,   106.,
      159.,  212.,  270.,  324.,  378.,  432.,  495.,  550.,  605.,  660.,
      728.,  784.,  840.,  896.,  57.,   114.,  171.,  228.,  290.,  348.,
      406.,  464.,  531.,  590.,  649.,  708.,  780.,  840.,  900.,  960.,
      61.,   122.,  183.,  244.,  310.,  372.,  434.,  496.,  567.,  630.,
      693.,  756.,  832.,  896.,  960.,  1024., 65.,   130.,  195.,  260.,
      330.,  396.,  462.,  528.,  603.,  670.,  737.,  804.,  884.,  952.,
      1020., 1088., 69.,   138.,  207.,  276.,  350.,  420.,  490.,  560.,
      639.,  710.,  781.,  852.,  936.,  1008., 1080., 1152., 73.,   146.,
      219.,  292.,  370.,  444.,  518.,  592.,  675.,  750.,  825.,  900.,
      988.,  1064., 1140., 1216., 77.,   154.,  231.,  308.,  390.,  468.,
      546.,  624.,  711.,  790.,  869.,  948.,  1040., 1120., 1200., 1280.,
      81.,   162.,  243.,  324.,  410.,  492.,  574.,  656.,  747.,  830.,
      913.,  996.,  1092., 1176., 1260., 1344., 85.,   170.,  255.,  340.,
      430.,  516.,  602.,  688.,  783.,  870.,  957.,  1044., 1144., 1232.,
      1320., 1408., 89.,   178.,  267.,  356.,  450.,  540.,  630.,  720.,
      819.,  910.,  1001., 1092., 1196., 1288., 1380., 1472., 93.,   186.,
      279.,  372.,  470.,  564.,  658.,  752.,  855.,  950.,  1045., 1140.,
      1248., 1344., 1440., 1536.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    3.,    4.,    10.,   12.,   14.,   16.,   27.,   30.,
      33.,   36.,   52.,   56.,   60.,   64.,   5.,    10.,   15.,   20.,
      30.,   36.,   42.,   48.,   63.,   70.,   77.,   84.,   104.,  112.,
      120.,  128.,  9.,    18.,   27.,   36.,   50.,   60.,   70.,   80.,
      99.,   110.,  121.,  132.,  156.,  168.,  180.,  192.,  13.,   26.,
      39.,   52.,   70.,   84.,   98.,   112.,  135.,  150.,  165.,  180.,
      208.,  224.,  240.,  256.,  17.,   34.,   51.,   68.,   90.,   108.,
      126.,  144.,  171.,  190.,  209.,  228.,  260.,  280.,  300.,  320.,
      21.,   42.,   63.,   84.,   110.,  132.,  154.,  176.,  207.,  230.,
      253.,  276.,  312.,  336.,  360.,  384.,  25.,   50.,   75.,   100.,
      130.,  156.,  182.,  208.,  243.,  270.,  297.,  324.,  364.,  392.,
      420.,  448.,  29.,   58.,   87.,   116.,  150.,  180.,  210.,  240.,
      279.,  310.,  341.,  372.,  416.,  448.,  480.,  512.,  33.,   66.,
      99.,   132.,  170.,  204.,  238.,  272.,  315.,  350.,  385.,  420.,
      468.,  504.,  540.,  576.,  37.,   74.,   111.,  148.,  190.,  228.,
      266.,  304.,  351.,  390.,  429.,  468.,  520.,  560.,  600.,  640.,
      41.,   82.,   123.,  164.,  210.,  252.,  294.,  336.,  387.,  430.,
      473.,  516.,  572.,  616.,  660.,  704.,  45.,   90.,   135.,  180.,
      230.,  276.,  322.,  368.,  423.,  470.,  517.,  564.,  624.,  672.,
      720.,  768.,  49.,   98.,   147.,  196.,  250.,  300.,  350.,  400.,
      459.,  510.,  561.,  612.,  676.,  728.,  780.,  832.,  53.,   106.,
      159.,  212.,  270.,  324.,  378.,  432.,  495.,  550.,  605.,  660.,
      728.,  784.,  840.,  896.,  57.,   114.,  171.,  228.,  290.,  348.,
      406.,  464.,  531.,  590.,  649.,  708.,  780.,  840.,  900.,  960.,
      61.,   122.,  183.,  244.,  310.,  372.,  434.,  496.,  567.,  630.,
      693.,  756.,  832.,  896.,  960.,  1024., 65.,   130.,  195.,  260.,
      330.,  396.,  462.,  528.,  603.,  670.,  737.,  804.,  884.,  952.,
      1020., 1088., 69.,   138.,  207.,  276.,  350.,  420.,  490.,  560.,
      639.,  710.,  781.,  852.,  936.,  1008., 1080., 1152., 73.,   146.,
      219.,  292.,  370.,  444.,  518.,  592.,  675.,  750.,  825.,  900.,
      988.,  1064., 1140., 1216., 77.,   154.,  231.,  308.,  390.,  468.,
      546.,  624.,  711.,  790.,  869.,  948.,  1040., 1120., 1200., 1280.,
      81.,   162.,  243.,  324.,  410.,  492.,  574.,  656.,  747.,  830.,
      913.,  996.,  1092., 1176., 1260., 1344., 85.,   170.,  255.,  340.,
      430.,  516.,  602.,  688.,  783.,  870.,  957.,  1044., 1144., 1232.,
      1320., 1408., 89.,   178.,  267.,  356.,  450.,  540.,  630.,  720.,
      819.,  910.,  1001., 1092., 1196., 1288., 1380., 1472., 93.,   186.,
      279.,  372.,  470.,  564.,  658.,  752.,  855.,  950.,  1045., 1140.,
      1248., 1344., 1440., 1536.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12., 7.,  14., 8.,
      16., 9.,  18., 10., 20., 11., 22., 12., 24., 13., 26., 14., 28., 15., 30.,
      16., 32., 17., 34., 18., 36., 19., 38., 20., 40., 21., 42., 22., 44., 23.,
      46., 24., 48., 25., 50., 26., 52., 27., 54., 28., 56., 29., 58., 30., 60.,
      31., 62., 32., 64., 33., 66., 34., 68., 35., 70., 36., 72.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12., 7.,  14., 8.,
      16., 9.,  18., 10., 20., 11., 22., 12., 24., 13., 26., 14., 28., 15., 30.,
      16., 32., 17., 34., 18., 36., 19., 38., 20., 40., 21., 42., 22., 44., 23.,
      46., 24., 48., 25., 50., 26., 52., 27., 54., 28., 56., 29., 58., 30., 60.,
      31., 62., 32., 64., 33., 66., 34., 68., 35., 70., 36., 72.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   2.,  4.,  6.,   8.,   3.,  6.,  9.,   12.,
      4.,  8.,  12.,  16.,  5.,  10., 15.,  20.,  6.,  12., 18.,  24.,
      7.,  14., 21.,  28.,  8.,  16., 24.,  32.,  9.,  18., 27.,  36.,
      10., 20., 30.,  40.,  11., 22., 33.,  44.,  12., 24., 36.,  48.,
      13., 26., 39.,  52.,  14., 28., 42.,  56.,  15., 30., 45.,  60.,
      16., 32., 48.,  64.,  17., 34., 51.,  68.,  18., 36., 54.,  72.,
      19., 38., 57.,  76.,  20., 40., 60.,  80.,  21., 42., 63.,  84.,
      22., 44., 66.,  88.,  23., 46., 69.,  92.,  24., 48., 72.,  96.,
      25., 50., 75.,  100., 26., 52., 78.,  104., 27., 54., 81.,  108.,
      28., 56., 84.,  112., 29., 58., 87.,  116., 30., 60., 90.,  120.,
      31., 62., 93.,  124., 32., 64., 96.,  128., 33., 66., 99.,  132.,
      34., 68., 102., 136., 35., 70., 105., 140., 36., 72., 108., 144.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   2.,  4.,  6.,   8.,   3.,  6.,  9.,   12.,
      4.,  8.,  12.,  16.,  5.,  10., 15.,  20.,  6.,  12., 18.,  24.,
      7.,  14., 21.,  28.,  8.,  16., 24.,  32.,  9.,  18., 27.,  36.,
      10., 20., 30.,  40.,  11., 22., 33.,  44.,  12., 24., 36.,  48.,
      13., 26., 39.,  52.,  14., 28., 42.,  56.,  15., 30., 45.,  60.,
      16., 32., 48.,  64.,  17., 34., 51.,  68.,  18., 36., 54.,  72.,
      19., 38., 57.,  76.,  20., 40., 60.,  80.,  21., 42., 63.,  84.,
      22., 44., 66.,  88.,  23., 46., 69.,  92.,  24., 48., 72.,  96.,
      25., 50., 75.,  100., 26., 52., 78.,  104., 27., 54., 81.,  108.,
      28., 56., 84.,  112., 29., 58., 87.,  116., 30., 60., 90.,  120.,
      31., 62., 93.,  124., 32., 64., 96.,  128., 33., 66., 99.,  132.,
      34., 68., 102., 136., 35., 70., 105., 140., 36., 72., 108., 144.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,   3.,  8.,   5.,  12.,  7.,  16.,  9.,  20.,  11., 24.,
      13., 28.,  15., 32.,  17., 36.,  19., 40.,  21., 44.,  23., 48.,
      25., 52.,  27., 56.,  29., 60.,  31., 64.,  33., 68.,  35., 72.,
      37., 76.,  39., 80.,  41., 84.,  43., 88.,  45., 92.,  47., 96.,
      49., 100., 51., 104., 53., 108., 55., 112., 57., 116., 59., 120.,
      61., 124., 63., 128., 65., 132., 67., 136., 69., 140., 71., 144.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,   3.,  8.,   5.,  12.,  7.,  16.,  9.,  20.,  11., 24.,
      13., 28.,  15., 32.,  17., 36.,  19., 40.,  21., 44.,  23., 48.,
      25., 52.,  27., 56.,  29., 60.,  31., 64.,  33., 68.,  35., 72.,
      37., 76.,  39., 80.,  41., 84.,  43., 88.,  45., 92.,  47., 96.,
      49., 100., 51., 104., 53., 108., 55., 112., 57., 116., 59., 120.,
      61., 124., 63., 128., 65., 132., 67., 136., 69., 140., 71., 144.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,   6.,   8.,   3.,  6.,   12.,  16.,  5.,  10.,  18.,  24.,
      7.,  14.,  24.,  32.,  9.,  18.,  30.,  40.,  11., 22.,  36.,  48.,
      13., 26.,  42.,  56.,  15., 30.,  48.,  64.,  17., 34.,  54.,  72.,
      19., 38.,  60.,  80.,  21., 42.,  66.,  88.,  23., 46.,  72.,  96.,
      25., 50.,  78.,  104., 27., 54.,  84.,  112., 29., 58.,  90.,  120.,
      31., 62.,  96.,  128., 33., 66.,  102., 136., 35., 70.,  108., 144.,
      37., 74.,  114., 152., 39., 78.,  120., 160., 41., 82.,  126., 168.,
      43., 86.,  132., 176., 45., 90.,  138., 184., 47., 94.,  144., 192.,
      49., 98.,  150., 200., 51., 102., 156., 208., 53., 106., 162., 216.,
      55., 110., 168., 224., 57., 114., 174., 232., 59., 118., 180., 240.,
      61., 122., 186., 248., 63., 126., 192., 256., 65., 130., 198., 264.,
      67., 134., 204., 272., 69., 138., 210., 280., 71., 142., 216., 288.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,   6.,   8.,   3.,  6.,   12.,  16.,  5.,  10.,  18.,  24.,
      7.,  14.,  24.,  32.,  9.,  18.,  30.,  40.,  11., 22.,  36.,  48.,
      13., 26.,  42.,  56.,  15., 30.,  48.,  64.,  17., 34.,  54.,  72.,
      19., 38.,  60.,  80.,  21., 42.,  66.,  88.,  23., 46.,  72.,  96.,
      25., 50.,  78.,  104., 27., 54.,  84.,  112., 29., 58.,  90.,  120.,
      31., 62.,  96.,  128., 33., 66.,  102., 136., 35., 70.,  108., 144.,
      37., 74.,  114., 152., 39., 78.,  120., 160., 41., 82.,  126., 168.,
      43., 86.,  132., 176., 45., 90.,  138., 184., 47., 94.,  144., 192.,
      49., 98.,  150., 200., 51., 102., 156., 208., 53., 106., 162., 216.,
      55., 110., 168., 224., 57., 114., 174., 232., 59., 118., 180., 240.,
      61., 122., 186., 248., 63., 126., 192., 256., 65., 130., 198., 264.,
      67., 134., 204., 272., 69., 138., 210., 280., 71., 142., 216., 288.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  3.,   6.,   9.,   12.,
      20.,  24.,  28.,  32.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      7.,   14.,  21.,  28.,  40.,  48.,  56.,  64.,  9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  11.,  22.,  33.,  44.,  60.,  72.,  84.,  96.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 15.,  30.,  45.,  60.,
      80.,  96.,  112., 128., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      19.,  38.,  57.,  76.,  100., 120., 140., 160., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 23.,  46.,  69.,  92.,  120., 144., 168., 192.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 27.,  54.,  81.,  108.,
      140., 168., 196., 224., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      31.,  62.,  93.,  124., 160., 192., 224., 256., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 35.,  70.,  105., 140., 180., 216., 252., 288.,
      37.,  74.,  111., 148., 190., 228., 266., 304., 39.,  78.,  117., 156.,
      200., 240., 280., 320., 41.,  82.,  123., 164., 210., 252., 294., 336.,
      43.,  86.,  129., 172., 220., 264., 308., 352., 45.,  90.,  135., 180.,
      230., 276., 322., 368., 47.,  94.,  141., 188., 240., 288., 336., 384.,
      49.,  98.,  147., 196., 250., 300., 350., 400., 51.,  102., 153., 204.,
      260., 312., 364., 416., 53.,  106., 159., 212., 270., 324., 378., 432.,
      55.,  110., 165., 220., 280., 336., 392., 448., 57.,  114., 171., 228.,
      290., 348., 406., 464., 59.,  118., 177., 236., 300., 360., 420., 480.,
      61.,  122., 183., 244., 310., 372., 434., 496., 63.,  126., 189., 252.,
      320., 384., 448., 512., 65.,  130., 195., 260., 330., 396., 462., 528.,
      67.,  134., 201., 268., 340., 408., 476., 544., 69.,  138., 207., 276.,
      350., 420., 490., 560., 71.,  142., 213., 284., 360., 432., 504., 576.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  3.,   6.,   9.,   12.,
      20.,  24.,  28.,  32.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      7.,   14.,  21.,  28.,  40.,  48.,  56.,  64.,  9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  11.,  22.,  33.,  44.,  60.,  72.,  84.,  96.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 15.,  30.,  45.,  60.,
      80.,  96.,  112., 128., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      19.,  38.,  57.,  76.,  100., 120., 140., 160., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 23.,  46.,  69.,  92.,  120., 144., 168., 192.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 27.,  54.,  81.,  108.,
      140., 168., 196., 224., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      31.,  62.,  93.,  124., 160., 192., 224., 256., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 35.,  70.,  105., 140., 180., 216., 252., 288.,
      37.,  74.,  111., 148., 190., 228., 266., 304., 39.,  78.,  117., 156.,
      200., 240., 280., 320., 41.,  82.,  123., 164., 210., 252., 294., 336.,
      43.,  86.,  129., 172., 220., 264., 308., 352., 45.,  90.,  135., 180.,
      230., 276., 322., 368., 47.,  94.,  141., 188., 240., 288., 336., 384.,
      49.,  98.,  147., 196., 250., 300., 350., 400., 51.,  102., 153., 204.,
      260., 312., 364., 416., 53.,  106., 159., 212., 270., 324., 378., 432.,
      55.,  110., 165., 220., 280., 336., 392., 448., 57.,  114., 171., 228.,
      290., 348., 406., 464., 59.,  118., 177., 236., 300., 360., 420., 480.,
      61.,  122., 183., 244., 310., 372., 434., 496., 63.,  126., 189., 252.,
      320., 384., 448., 512., 65.,  130., 195., 260., 330., 396., 462., 528.,
      67.,  134., 201., 268., 340., 408., 476., 544., 69.,  138., 207., 276.,
      350., 420., 490., 560., 71.,  142., 213., 284., 360., 432., 504., 576.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   9.,   16.,  5.,   12.,  21.,  32.,  9.,   20.,  33.,  48.,
      13.,  28.,  45.,  64.,  17.,  36.,  57.,  80.,  21.,  44.,  69.,  96.,
      25.,  52.,  81.,  112., 29.,  60.,  93.,  128., 33.,  68.,  105., 144.,
      37.,  76.,  117., 160., 41.,  84.,  129., 176., 45.,  92.,  141., 192.,
      49.,  100., 153., 208., 53.,  108., 165., 224., 57.,  116., 177., 240.,
      61.,  124., 189., 256., 65.,  132., 201., 272., 69.,  140., 213., 288.,
      73.,  148., 225., 304., 77.,  156., 237., 320., 81.,  164., 249., 336.,
      85.,  172., 261., 352., 89.,  180., 273., 368., 93.,  188., 285., 384.,
      97.,  196., 297., 400., 101., 204., 309., 416., 105., 212., 321., 432.,
      109., 220., 333., 448., 113., 228., 345., 464., 117., 236., 357., 480.,
      121., 244., 369., 496., 125., 252., 381., 512., 129., 260., 393., 528.,
      133., 268., 405., 544., 137., 276., 417., 560., 141., 284., 429., 576.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   9.,   16.,  5.,   12.,  21.,  32.,  9.,   20.,  33.,  48.,
      13.,  28.,  45.,  64.,  17.,  36.,  57.,  80.,  21.,  44.,  69.,  96.,
      25.,  52.,  81.,  112., 29.,  60.,  93.,  128., 33.,  68.,  105., 144.,
      37.,  76.,  117., 160., 41.,  84.,  129., 176., 45.,  92.,  141., 192.,
      49.,  100., 153., 208., 53.,  108., 165., 224., 57.,  116., 177., 240.,
      61.,  124., 189., 256., 65.,  132., 201., 272., 69.,  140., 213., 288.,
      73.,  148., 225., 304., 77.,  156., 237., 320., 81.,  164., 249., 336.,
      85.,  172., 261., 352., 89.,  180., 273., 368., 93.,  188., 285., 384.,
      97.,  196., 297., 400., 101., 204., 309., 416., 105., 212., 321., 432.,
      109., 220., 333., 448., 113., 228., 345., 464., 117., 236., 357., 480.,
      121., 244., 369., 496., 125., 252., 381., 512., 129., 260., 393., 528.,
      133., 268., 405., 544., 137., 276., 417., 560., 141., 284., 429., 576.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,   6.,    8.,   15.,   18.,  28.,  32.,   5.,   10.,  18.,
      24.,   35.,  42.,   56.,  64.,   9.,   18.,  30.,   40.,  55.,  66.,
      84.,   96.,  13.,   26.,  42.,   56.,  75.,  90.,   112., 128., 17.,
      34.,   54.,  72.,   95.,  114.,  140., 160., 21.,   42.,  66.,  88.,
      115.,  138., 168.,  192., 25.,   50.,  78.,  104.,  135., 162., 196.,
      224.,  29.,  58.,   90.,  120.,  155., 186., 224.,  256., 33.,  66.,
      102.,  136., 175.,  210., 252.,  288., 37.,  74.,   114., 152., 195.,
      234.,  280., 320.,  41.,  82.,   126., 168., 215.,  258., 308., 352.,
      45.,   90.,  138.,  184., 235.,  282., 336., 384.,  49.,  98.,  150.,
      200.,  255., 306.,  364., 416.,  53.,  106., 162.,  216., 275., 330.,
      392.,  448., 57.,   114., 174.,  232., 295., 354.,  420., 480., 61.,
      122.,  186., 248.,  315., 378.,  448., 512., 65.,   130., 198., 264.,
      335.,  402., 476.,  544., 69.,   138., 210., 280.,  355., 426., 504.,
      576.,  73.,  146.,  222., 296.,  375., 450., 532.,  608., 77.,  154.,
      234.,  312., 395.,  474., 560.,  640., 81.,  162.,  246., 328., 415.,
      498.,  588., 672.,  85.,  170.,  258., 344., 435.,  522., 616., 704.,
      89.,   178., 270.,  360., 455.,  546., 644., 736.,  93.,  186., 282.,
      376.,  475., 570.,  672., 768.,  97.,  194., 294.,  392., 495., 594.,
      700.,  800., 101.,  202., 306.,  408., 515., 618.,  728., 832., 105.,
      210.,  318., 424.,  535., 642.,  756., 864., 109.,  218., 330., 440.,
      555.,  666., 784.,  896., 113.,  226., 342., 456.,  575., 690., 812.,
      928.,  117., 234.,  354., 472.,  595., 714., 840.,  960., 121., 242.,
      366.,  488., 615.,  738., 868.,  992., 125., 250.,  378., 504., 635.,
      762.,  896., 1024., 129., 258.,  390., 520., 655.,  786., 924., 1056.,
      133.,  266., 402.,  536., 675.,  810., 952., 1088., 137., 274., 414.,
      552.,  695., 834.,  980., 1120., 141., 282., 426.,  568., 715., 858.,
      1008., 1152.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,   6.,    8.,   15.,   18.,  28.,  32.,   5.,   10.,  18.,
      24.,   35.,  42.,   56.,  64.,   9.,   18.,  30.,   40.,  55.,  66.,
      84.,   96.,  13.,   26.,  42.,   56.,  75.,  90.,   112., 128., 17.,
      34.,   54.,  72.,   95.,  114.,  140., 160., 21.,   42.,  66.,  88.,
      115.,  138., 168.,  192., 25.,   50.,  78.,  104.,  135., 162., 196.,
      224.,  29.,  58.,   90.,  120.,  155., 186., 224.,  256., 33.,  66.,
      102.,  136., 175.,  210., 252.,  288., 37.,  74.,   114., 152., 195.,
      234.,  280., 320.,  41.,  82.,   126., 168., 215.,  258., 308., 352.,
      45.,   90.,  138.,  184., 235.,  282., 336., 384.,  49.,  98.,  150.,
      200.,  255., 306.,  364., 416.,  53.,  106., 162.,  216., 275., 330.,
      392.,  448., 57.,   114., 174.,  232., 295., 354.,  420., 480., 61.,
      122.,  186., 248.,  315., 378.,  448., 512., 65.,   130., 198., 264.,
      335.,  402., 476.,  544., 69.,   138., 210., 280.,  355., 426., 504.,
      576.,  73.,  146.,  222., 296.,  375., 450., 532.,  608., 77.,  154.,
      234.,  312., 395.,  474., 560.,  640., 81.,  162.,  246., 328., 415.,
      498.,  588., 672.,  85.,  170.,  258., 344., 435.,  522., 616., 704.,
      89.,   178., 270.,  360., 455.,  546., 644., 736.,  93.,  186., 282.,
      376.,  475., 570.,  672., 768.,  97.,  194., 294.,  392., 495., 594.,
      700.,  800., 101.,  202., 306.,  408., 515., 618.,  728., 832., 105.,
      210.,  318., 424.,  535., 642.,  756., 864., 109.,  218., 330., 440.,
      555.,  666., 784.,  896., 113.,  226., 342., 456.,  575., 690., 812.,
      928.,  117., 234.,  354., 472.,  595., 714., 840.,  960., 121., 242.,
      366.,  488., 615.,  738., 868.,  992., 125., 250.,  378., 504., 635.,
      762.,  896., 1024., 129., 258.,  390., 520., 655.,  786., 924., 1056.,
      133.,  266., 402.,  536., 675.,  810., 952., 1088., 137., 274., 414.,
      552.,  695., 834.,  980., 1120., 141., 282., 426.,  568., 715., 858.,
      1008., 1152.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    3.,    4.,    10.,   12.,   14.,   16.,   27.,   30.,
      33.,   36.,   52.,   56.,   60.,   64.,   5.,    10.,   15.,   20.,
      30.,   36.,   42.,   48.,   63.,   70.,   77.,   84.,   104.,  112.,
      120.,  128.,  9.,    18.,   27.,   36.,   50.,   60.,   70.,   80.,
      99.,   110.,  121.,  132.,  156.,  168.,  180.,  192.,  13.,   26.,
      39.,   52.,   70.,   84.,   98.,   112.,  135.,  150.,  165.,  180.,
      208.,  224.,  240.,  256.,  17.,   34.,   51.,   68.,   90.,   108.,
      126.,  144.,  171.,  190.,  209.,  228.,  260.,  280.,  300.,  320.,
      21.,   42.,   63.,   84.,   110.,  132.,  154.,  176.,  207.,  230.,
      253.,  276.,  312.,  336.,  360.,  384.,  25.,   50.,   75.,   100.,
      130.,  156.,  182.,  208.,  243.,  270.,  297.,  324.,  364.,  392.,
      420.,  448.,  29.,   58.,   87.,   116.,  150.,  180.,  210.,  240.,
      279.,  310.,  341.,  372.,  416.,  448.,  480.,  512.,  33.,   66.,
      99.,   132.,  170.,  204.,  238.,  272.,  315.,  350.,  385.,  420.,
      468.,  504.,  540.,  576.,  37.,   74.,   111.,  148.,  190.,  228.,
      266.,  304.,  351.,  390.,  429.,  468.,  520.,  560.,  600.,  640.,
      41.,   82.,   123.,  164.,  210.,  252.,  294.,  336.,  387.,  430.,
      473.,  516.,  572.,  616.,  660.,  704.,  45.,   90.,   135.,  180.,
      230.,  276.,  322.,  368.,  423.,  470.,  517.,  564.,  624.,  672.,
      720.,  768.,  49.,   98.,   147.,  196.,  250.,  300.,  350.,  400.,
      459.,  510.,  561.,  612.,  676.,  728.,  780.,  832.,  53.,   106.,
      159.,  212.,  270.,  324.,  378.,  432.,  495.,  550.,  605.,  660.,
      728.,  784.,  840.,  896.,  57.,   114.,  171.,  228.,  290.,  348.,
      406.,  464.,  531.,  590.,  649.,  708.,  780.,  840.,  900.,  960.,
      61.,   122.,  183.,  244.,  310.,  372.,  434.,  496.,  567.,  630.,
      693.,  756.,  832.,  896.,  960.,  1024., 65.,   130.,  195.,  260.,
      330.,  396.,  462.,  528.,  603.,  670.,  737.,  804.,  884.,  952.,
      1020., 1088., 69.,   138.,  207.,  276.,  350.,  420.,  490.,  560.,
      639.,  710.,  781.,  852.,  936.,  1008., 1080., 1152., 73.,   146.,
      219.,  292.,  370.,  444.,  518.,  592.,  675.,  750.,  825.,  900.,
      988.,  1064., 1140., 1216., 77.,   154.,  231.,  308.,  390.,  468.,
      546.,  624.,  711.,  790.,  869.,  948.,  1040., 1120., 1200., 1280.,
      81.,   162.,  243.,  324.,  410.,  492.,  574.,  656.,  747.,  830.,
      913.,  996.,  1092., 1176., 1260., 1344., 85.,   170.,  255.,  340.,
      430.,  516.,  602.,  688.,  783.,  870.,  957.,  1044., 1144., 1232.,
      1320., 1408., 89.,   178.,  267.,  356.,  450.,  540.,  630.,  720.,
      819.,  910.,  1001., 1092., 1196., 1288., 1380., 1472., 93.,   186.,
      279.,  372.,  470.,  564.,  658.,  752.,  855.,  950.,  1045., 1140.,
      1248., 1344., 1440., 1536., 97.,   194.,  291.,  388.,  490.,  588.,
      686.,  784.,  891.,  990.,  1089., 1188., 1300., 1400., 1500., 1600.,
      101.,  202.,  303.,  404.,  510.,  612.,  714.,  816.,  927.,  1030.,
      1133., 1236., 1352., 1456., 1560., 1664., 105.,  210.,  315.,  420.,
      530.,  636.,  742.,  848.,  963.,  1070., 1177., 1284., 1404., 1512.,
      1620., 1728., 109.,  218.,  327.,  436.,  550.,  660.,  770.,  880.,
      999.,  1110., 1221., 1332., 1456., 1568., 1680., 1792., 113.,  226.,
      339.,  452.,  570.,  684.,  798.,  912.,  1035., 1150., 1265., 1380.,
      1508., 1624., 1740., 1856., 117.,  234.,  351.,  468.,  590.,  708.,
      826.,  944.,  1071., 1190., 1309., 1428., 1560., 1680., 1800., 1920.,
      121.,  242.,  363.,  484.,  610.,  732.,  854.,  976.,  1107., 1230.,
      1353., 1476., 1612., 1736., 1860., 1984., 125.,  250.,  375.,  500.,
      630.,  756.,  882.,  1008., 1143., 1270., 1397., 1524., 1664., 1792.,
      1920., 2048., 129.,  258.,  387.,  516.,  650.,  780.,  910.,  1040.,
      1179., 1310., 1441., 1572., 1716., 1848., 1980., 2112., 133.,  266.,
      399.,  532.,  670.,  804.,  938.,  1072., 1215., 1350., 1485., 1620.,
      1768., 1904., 2040., 2176., 137.,  274.,  411.,  548.,  690.,  828.,
      966.,  1104., 1251., 1390., 1529., 1668., 1820., 1960., 2100., 2240.,
      141.,  282.,  423.,  564.,  710.,  852.,  994.,  1136., 1287., 1430.,
      1573., 1716., 1872., 2016., 2160., 2304.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    3.,    4.,    10.,   12.,   14.,   16.,   27.,   30.,
      33.,   36.,   52.,   56.,   60.,   64.,   5.,    10.,   15.,   20.,
      30.,   36.,   42.,   48.,   63.,   70.,   77.,   84.,   104.,  112.,
      120.,  128.,  9.,    18.,   27.,   36.,   50.,   60.,   70.,   80.,
      99.,   110.,  121.,  132.,  156.,  168.,  180.,  192.,  13.,   26.,
      39.,   52.,   70.,   84.,   98.,   112.,  135.,  150.,  165.,  180.,
      208.,  224.,  240.,  256.,  17.,   34.,   51.,   68.,   90.,   108.,
      126.,  144.,  171.,  190.,  209.,  228.,  260.,  280.,  300.,  320.,
      21.,   42.,   63.,   84.,   110.,  132.,  154.,  176.,  207.,  230.,
      253.,  276.,  312.,  336.,  360.,  384.,  25.,   50.,   75.,   100.,
      130.,  156.,  182.,  208.,  243.,  270.,  297.,  324.,  364.,  392.,
      420.,  448.,  29.,   58.,   87.,   116.,  150.,  180.,  210.,  240.,
      279.,  310.,  341.,  372.,  416.,  448.,  480.,  512.,  33.,   66.,
      99.,   132.,  170.,  204.,  238.,  272.,  315.,  350.,  385.,  420.,
      468.,  504.,  540.,  576.,  37.,   74.,   111.,  148.,  190.,  228.,
      266.,  304.,  351.,  390.,  429.,  468.,  520.,  560.,  600.,  640.,
      41.,   82.,   123.,  164.,  210.,  252.,  294.,  336.,  387.,  430.,
      473.,  516.,  572.,  616.,  660.,  704.,  45.,   90.,   135.,  180.,
      230.,  276.,  322.,  368.,  423.,  470.,  517.,  564.,  624.,  672.,
      720.,  768.,  49.,   98.,   147.,  196.,  250.,  300.,  350.,  400.,
      459.,  510.,  561.,  612.,  676.,  728.,  780.,  832.,  53.,   106.,
      159.,  212.,  270.,  324.,  378.,  432.,  495.,  550.,  605.,  660.,
      728.,  784.,  840.,  896.,  57.,   114.,  171.,  228.,  290.,  348.,
      406.,  464.,  531.,  590.,  649.,  708.,  780.,  840.,  900.,  960.,
      61.,   122.,  183.,  244.,  310.,  372.,  434.,  496.,  567.,  630.,
      693.,  756.,  832.,  896.,  960.,  1024., 65.,   130.,  195.,  260.,
      330.,  396.,  462.,  528.,  603.,  670.,  737.,  804.,  884.,  952.,
      1020., 1088., 69.,   138.,  207.,  276.,  350.,  420.,  490.,  560.,
      639.,  710.,  781.,  852.,  936.,  1008., 1080., 1152., 73.,   146.,
      219.,  292.,  370.,  444.,  518.,  592.,  675.,  750.,  825.,  900.,
      988.,  1064., 1140., 1216., 77.,   154.,  231.,  308.,  390.,  468.,
      546.,  624.,  711.,  790.,  869.,  948.,  1040., 1120., 1200., 1280.,
      81.,   162.,  243.,  324.,  410.,  492.,  574.,  656.,  747.,  830.,
      913.,  996.,  1092., 1176., 1260., 1344., 85.,   170.,  255.,  340.,
      430.,  516.,  602.,  688.,  783.,  870.,  957.,  1044., 1144., 1232.,
      1320., 1408., 89.,   178.,  267.,  356.,  450.,  540.,  630.,  720.,
      819.,  910.,  1001., 1092., 1196., 1288., 1380., 1472., 93.,   186.,
      279.,  372.,  470.,  564.,  658.,  752.,  855.,  950.,  1045., 1140.,
      1248., 1344., 1440., 1536., 97.,   194.,  291.,  388.,  490.,  588.,
      686.,  784.,  891.,  990.,  1089., 1188., 1300., 1400., 1500., 1600.,
      101.,  202.,  303.,  404.,  510.,  612.,  714.,  816.,  927.,  1030.,
      1133., 1236., 1352., 1456., 1560., 1664., 105.,  210.,  315.,  420.,
      530.,  636.,  742.,  848.,  963.,  1070., 1177., 1284., 1404., 1512.,
      1620., 1728., 109.,  218.,  327.,  436.,  550.,  660.,  770.,  880.,
      999.,  1110., 1221., 1332., 1456., 1568., 1680., 1792., 113.,  226.,
      339.,  452.,  570.,  684.,  798.,  912.,  1035., 1150., 1265., 1380.,
      1508., 1624., 1740., 1856., 117.,  234.,  351.,  468.,  590.,  708.,
      826.,  944.,  1071., 1190., 1309., 1428., 1560., 1680., 1800., 1920.,
      121.,  242.,  363.,  484.,  610.,  732.,  854.,  976.,  1107., 1230.,
      1353., 1476., 1612., 1736., 1860., 1984., 125.,  250.,  375.,  500.,
      630.,  756.,  882.,  1008., 1143., 1270., 1397., 1524., 1664., 1792.,
      1920., 2048., 129.,  258.,  387.,  516.,  650.,  780.,  910.,  1040.,
      1179., 1310., 1441., 1572., 1716., 1848., 1980., 2112., 133.,  266.,
      399.,  532.,  670.,  804.,  938.,  1072., 1215., 1350., 1485., 1620.,
      1768., 1904., 2040., 2176., 137.,  274.,  411.,  548.,  690.,  828.,
      966.,  1104., 1251., 1390., 1529., 1668., 1820., 1960., 2100., 2240.,
      141.,  282.,  423.,  564.,  710.,  852.,  994.,  1136., 1287., 1430.,
      1573., 1716., 1872., 2016., 2160., 2304.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.,
      37., 38., 39., 40., 41., 42., 43., 44., 45., 46., 47., 48.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.,
      37., 38., 39., 40., 41., 42., 43., 44., 45., 46., 47., 48.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12., 7.,  14.,
      8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24., 13., 26., 14., 28.,
      15., 30., 16., 32., 17., 34., 18., 36., 19., 38., 20., 40., 21., 42.,
      22., 44., 23., 46., 24., 48., 25., 50., 26., 52., 27., 54., 28., 56.,
      29., 58., 30., 60., 31., 62., 32., 64., 33., 66., 34., 68., 35., 70.,
      36., 72., 37., 74., 38., 76., 39., 78., 40., 80., 41., 82., 42., 84.,
      43., 86., 44., 88., 45., 90., 46., 92., 47., 94., 48., 96.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12., 7.,  14.,
      8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24., 13., 26., 14., 28.,
      15., 30., 16., 32., 17., 34., 18., 36., 19., 38., 20., 40., 21., 42.,
      22., 44., 23., 46., 24., 48., 25., 50., 26., 52., 27., 54., 28., 56.,
      29., 58., 30., 60., 31., 62., 32., 64., 33., 66., 34., 68., 35., 70.,
      36., 72., 37., 74., 38., 76., 39., 78., 40., 80., 41., 82., 42., 84.,
      43., 86., 44., 88., 45., 90., 46., 92., 47., 94., 48., 96.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   2.,  4.,  6.,   8.,   3.,  6.,  9.,   12.,
      4.,  8.,  12.,  16.,  5.,  10., 15.,  20.,  6.,  12., 18.,  24.,
      7.,  14., 21.,  28.,  8.,  16., 24.,  32.,  9.,  18., 27.,  36.,
      10., 20., 30.,  40.,  11., 22., 33.,  44.,  12., 24., 36.,  48.,
      13., 26., 39.,  52.,  14., 28., 42.,  56.,  15., 30., 45.,  60.,
      16., 32., 48.,  64.,  17., 34., 51.,  68.,  18., 36., 54.,  72.,
      19., 38., 57.,  76.,  20., 40., 60.,  80.,  21., 42., 63.,  84.,
      22., 44., 66.,  88.,  23., 46., 69.,  92.,  24., 48., 72.,  96.,
      25., 50., 75.,  100., 26., 52., 78.,  104., 27., 54., 81.,  108.,
      28., 56., 84.,  112., 29., 58., 87.,  116., 30., 60., 90.,  120.,
      31., 62., 93.,  124., 32., 64., 96.,  128., 33., 66., 99.,  132.,
      34., 68., 102., 136., 35., 70., 105., 140., 36., 72., 108., 144.,
      37., 74., 111., 148., 38., 76., 114., 152., 39., 78., 117., 156.,
      40., 80., 120., 160., 41., 82., 123., 164., 42., 84., 126., 168.,
      43., 86., 129., 172., 44., 88., 132., 176., 45., 90., 135., 180.,
      46., 92., 138., 184., 47., 94., 141., 188., 48., 96., 144., 192.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   2.,  4.,  6.,   8.,   3.,  6.,  9.,   12.,
      4.,  8.,  12.,  16.,  5.,  10., 15.,  20.,  6.,  12., 18.,  24.,
      7.,  14., 21.,  28.,  8.,  16., 24.,  32.,  9.,  18., 27.,  36.,
      10., 20., 30.,  40.,  11., 22., 33.,  44.,  12., 24., 36.,  48.,
      13., 26., 39.,  52.,  14., 28., 42.,  56.,  15., 30., 45.,  60.,
      16., 32., 48.,  64.,  17., 34., 51.,  68.,  18., 36., 54.,  72.,
      19., 38., 57.,  76.,  20., 40., 60.,  80.,  21., 42., 63.,  84.,
      22., 44., 66.,  88.,  23., 46., 69.,  92.,  24., 48., 72.,  96.,
      25., 50., 75.,  100., 26., 52., 78.,  104., 27., 54., 81.,  108.,
      28., 56., 84.,  112., 29., 58., 87.,  116., 30., 60., 90.,  120.,
      31., 62., 93.,  124., 32., 64., 96.,  128., 33., 66., 99.,  132.,
      34., 68., 102., 136., 35., 70., 105., 140., 36., 72., 108., 144.,
      37., 74., 111., 148., 38., 76., 114., 152., 39., 78., 117., 156.,
      40., 80., 120., 160., 41., 82., 123., 164., 42., 84., 126., 168.,
      43., 86., 129., 172., 44., 88., 132., 176., 45., 90., 135., 180.,
      46., 92., 138., 184., 47., 94., 141., 188., 48., 96., 144., 192.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,   3.,  8.,   5.,  12.,  7.,  16.,  9.,  20.,  11., 24.,
      13., 28.,  15., 32.,  17., 36.,  19., 40.,  21., 44.,  23., 48.,
      25., 52.,  27., 56.,  29., 60.,  31., 64.,  33., 68.,  35., 72.,
      37., 76.,  39., 80.,  41., 84.,  43., 88.,  45., 92.,  47., 96.,
      49., 100., 51., 104., 53., 108., 55., 112., 57., 116., 59., 120.,
      61., 124., 63., 128., 65., 132., 67., 136., 69., 140., 71., 144.,
      73., 148., 75., 152., 77., 156., 79., 160., 81., 164., 83., 168.,
      85., 172., 87., 176., 89., 180., 91., 184., 93., 188., 95., 192.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,   3.,  8.,   5.,  12.,  7.,  16.,  9.,  20.,  11., 24.,
      13., 28.,  15., 32.,  17., 36.,  19., 40.,  21., 44.,  23., 48.,
      25., 52.,  27., 56.,  29., 60.,  31., 64.,  33., 68.,  35., 72.,
      37., 76.,  39., 80.,  41., 84.,  43., 88.,  45., 92.,  47., 96.,
      49., 100., 51., 104., 53., 108., 55., 112., 57., 116., 59., 120.,
      61., 124., 63., 128., 65., 132., 67., 136., 69., 140., 71., 144.,
      73., 148., 75., 152., 77., 156., 79., 160., 81., 164., 83., 168.,
      85., 172., 87., 176., 89., 180., 91., 184., 93., 188., 95., 192.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,   6.,   8.,   3.,  6.,   12.,  16.,  5.,  10.,  18.,  24.,
      7.,  14.,  24.,  32.,  9.,  18.,  30.,  40.,  11., 22.,  36.,  48.,
      13., 26.,  42.,  56.,  15., 30.,  48.,  64.,  17., 34.,  54.,  72.,
      19., 38.,  60.,  80.,  21., 42.,  66.,  88.,  23., 46.,  72.,  96.,
      25., 50.,  78.,  104., 27., 54.,  84.,  112., 29., 58.,  90.,  120.,
      31., 62.,  96.,  128., 33., 66.,  102., 136., 35., 70.,  108., 144.,
      37., 74.,  114., 152., 39., 78.,  120., 160., 41., 82.,  126., 168.,
      43., 86.,  132., 176., 45., 90.,  138., 184., 47., 94.,  144., 192.,
      49., 98.,  150., 200., 51., 102., 156., 208., 53., 106., 162., 216.,
      55., 110., 168., 224., 57., 114., 174., 232., 59., 118., 180., 240.,
      61., 122., 186., 248., 63., 126., 192., 256., 65., 130., 198., 264.,
      67., 134., 204., 272., 69., 138., 210., 280., 71., 142., 216., 288.,
      73., 146., 222., 296., 75., 150., 228., 304., 77., 154., 234., 312.,
      79., 158., 240., 320., 81., 162., 246., 328., 83., 166., 252., 336.,
      85., 170., 258., 344., 87., 174., 264., 352., 89., 178., 270., 360.,
      91., 182., 276., 368., 93., 186., 282., 376., 95., 190., 288., 384.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,   6.,   8.,   3.,  6.,   12.,  16.,  5.,  10.,  18.,  24.,
      7.,  14.,  24.,  32.,  9.,  18.,  30.,  40.,  11., 22.,  36.,  48.,
      13., 26.,  42.,  56.,  15., 30.,  48.,  64.,  17., 34.,  54.,  72.,
      19., 38.,  60.,  80.,  21., 42.,  66.,  88.,  23., 46.,  72.,  96.,
      25., 50.,  78.,  104., 27., 54.,  84.,  112., 29., 58.,  90.,  120.,
      31., 62.,  96.,  128., 33., 66.,  102., 136., 35., 70.,  108., 144.,
      37., 74.,  114., 152., 39., 78.,  120., 160., 41., 82.,  126., 168.,
      43., 86.,  132., 176., 45., 90.,  138., 184., 47., 94.,  144., 192.,
      49., 98.,  150., 200., 51., 102., 156., 208., 53., 106., 162., 216.,
      55., 110., 168., 224., 57., 114., 174., 232., 59., 118., 180., 240.,
      61., 122., 186., 248., 63., 126., 192., 256., 65., 130., 198., 264.,
      67., 134., 204., 272., 69., 138., 210., 280., 71., 142., 216., 288.,
      73., 146., 222., 296., 75., 150., 228., 304., 77., 154., 234., 312.,
      79., 158., 240., 320., 81., 162., 246., 328., 83., 166., 252., 336.,
      85., 170., 258., 344., 87., 174., 264., 352., 89., 178., 270., 360.,
      91., 182., 276., 368., 93., 186., 282., 376., 95., 190., 288., 384.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  3.,   6.,   9.,   12.,
      20.,  24.,  28.,  32.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      7.,   14.,  21.,  28.,  40.,  48.,  56.,  64.,  9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  11.,  22.,  33.,  44.,  60.,  72.,  84.,  96.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 15.,  30.,  45.,  60.,
      80.,  96.,  112., 128., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      19.,  38.,  57.,  76.,  100., 120., 140., 160., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 23.,  46.,  69.,  92.,  120., 144., 168., 192.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 27.,  54.,  81.,  108.,
      140., 168., 196., 224., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      31.,  62.,  93.,  124., 160., 192., 224., 256., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 35.,  70.,  105., 140., 180., 216., 252., 288.,
      37.,  74.,  111., 148., 190., 228., 266., 304., 39.,  78.,  117., 156.,
      200., 240., 280., 320., 41.,  82.,  123., 164., 210., 252., 294., 336.,
      43.,  86.,  129., 172., 220., 264., 308., 352., 45.,  90.,  135., 180.,
      230., 276., 322., 368., 47.,  94.,  141., 188., 240., 288., 336., 384.,
      49.,  98.,  147., 196., 250., 300., 350., 400., 51.,  102., 153., 204.,
      260., 312., 364., 416., 53.,  106., 159., 212., 270., 324., 378., 432.,
      55.,  110., 165., 220., 280., 336., 392., 448., 57.,  114., 171., 228.,
      290., 348., 406., 464., 59.,  118., 177., 236., 300., 360., 420., 480.,
      61.,  122., 183., 244., 310., 372., 434., 496., 63.,  126., 189., 252.,
      320., 384., 448., 512., 65.,  130., 195., 260., 330., 396., 462., 528.,
      67.,  134., 201., 268., 340., 408., 476., 544., 69.,  138., 207., 276.,
      350., 420., 490., 560., 71.,  142., 213., 284., 360., 432., 504., 576.,
      73.,  146., 219., 292., 370., 444., 518., 592., 75.,  150., 225., 300.,
      380., 456., 532., 608., 77.,  154., 231., 308., 390., 468., 546., 624.,
      79.,  158., 237., 316., 400., 480., 560., 640., 81.,  162., 243., 324.,
      410., 492., 574., 656., 83.,  166., 249., 332., 420., 504., 588., 672.,
      85.,  170., 255., 340., 430., 516., 602., 688., 87.,  174., 261., 348.,
      440., 528., 616., 704., 89.,  178., 267., 356., 450., 540., 630., 720.,
      91.,  182., 273., 364., 460., 552., 644., 736., 93.,  186., 279., 372.,
      470., 564., 658., 752., 95.,  190., 285., 380., 480., 576., 672., 768.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   10.,  12.,  14.,  16.,  3.,   6.,   9.,   12.,
      20.,  24.,  28.,  32.,  5.,   10.,  15.,  20.,  30.,  36.,  42.,  48.,
      7.,   14.,  21.,  28.,  40.,  48.,  56.,  64.,  9.,   18.,  27.,  36.,
      50.,  60.,  70.,  80.,  11.,  22.,  33.,  44.,  60.,  72.,  84.,  96.,
      13.,  26.,  39.,  52.,  70.,  84.,  98.,  112., 15.,  30.,  45.,  60.,
      80.,  96.,  112., 128., 17.,  34.,  51.,  68.,  90.,  108., 126., 144.,
      19.,  38.,  57.,  76.,  100., 120., 140., 160., 21.,  42.,  63.,  84.,
      110., 132., 154., 176., 23.,  46.,  69.,  92.,  120., 144., 168., 192.,
      25.,  50.,  75.,  100., 130., 156., 182., 208., 27.,  54.,  81.,  108.,
      140., 168., 196., 224., 29.,  58.,  87.,  116., 150., 180., 210., 240.,
      31.,  62.,  93.,  124., 160., 192., 224., 256., 33.,  66.,  99.,  132.,
      170., 204., 238., 272., 35.,  70.,  105., 140., 180., 216., 252., 288.,
      37.,  74.,  111., 148., 190., 228., 266., 304., 39.,  78.,  117., 156.,
      200., 240., 280., 320., 41.,  82.,  123., 164., 210., 252., 294., 336.,
      43.,  86.,  129., 172., 220., 264., 308., 352., 45.,  90.,  135., 180.,
      230., 276., 322., 368., 47.,  94.,  141., 188., 240., 288., 336., 384.,
      49.,  98.,  147., 196., 250., 300., 350., 400., 51.,  102., 153., 204.,
      260., 312., 364., 416., 53.,  106., 159., 212., 270., 324., 378., 432.,
      55.,  110., 165., 220., 280., 336., 392., 448., 57.,  114., 171., 228.,
      290., 348., 406., 464., 59.,  118., 177., 236., 300., 360., 420., 480.,
      61.,  122., 183., 244., 310., 372., 434., 496., 63.,  126., 189., 252.,
      320., 384., 448., 512., 65.,  130., 195., 260., 330., 396., 462., 528.,
      67.,  134., 201., 268., 340., 408., 476., 544., 69.,  138., 207., 276.,
      350., 420., 490., 560., 71.,  142., 213., 284., 360., 432., 504., 576.,
      73.,  146., 219., 292., 370., 444., 518., 592., 75.,  150., 225., 300.,
      380., 456., 532., 608., 77.,  154., 231., 308., 390., 468., 546., 624.,
      79.,  158., 237., 316., 400., 480., 560., 640., 81.,  162., 243., 324.,
      410., 492., 574., 656., 83.,  166., 249., 332., 420., 504., 588., 672.,
      85.,  170., 255., 340., 430., 516., 602., 688., 87.,  174., 261., 348.,
      440., 528., 616., 704., 89.,  178., 267., 356., 450., 540., 630., 720.,
      91.,  182., 273., 364., 460., 552., 644., 736., 93.,  186., 279., 372.,
      470., 564., 658., 752., 95.,  190., 285., 380., 480., 576., 672., 768.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   9.,   16.,  5.,   12.,  21.,  32.,  9.,   20.,  33.,  48.,
      13.,  28.,  45.,  64.,  17.,  36.,  57.,  80.,  21.,  44.,  69.,  96.,
      25.,  52.,  81.,  112., 29.,  60.,  93.,  128., 33.,  68.,  105., 144.,
      37.,  76.,  117., 160., 41.,  84.,  129., 176., 45.,  92.,  141., 192.,
      49.,  100., 153., 208., 53.,  108., 165., 224., 57.,  116., 177., 240.,
      61.,  124., 189., 256., 65.,  132., 201., 272., 69.,  140., 213., 288.,
      73.,  148., 225., 304., 77.,  156., 237., 320., 81.,  164., 249., 336.,
      85.,  172., 261., 352., 89.,  180., 273., 368., 93.,  188., 285., 384.,
      97.,  196., 297., 400., 101., 204., 309., 416., 105., 212., 321., 432.,
      109., 220., 333., 448., 113., 228., 345., 464., 117., 236., 357., 480.,
      121., 244., 369., 496., 125., 252., 381., 512., 129., 260., 393., 528.,
      133., 268., 405., 544., 137., 276., 417., 560., 141., 284., 429., 576.,
      145., 292., 441., 592., 149., 300., 453., 608., 153., 308., 465., 624.,
      157., 316., 477., 640., 161., 324., 489., 656., 165., 332., 501., 672.,
      169., 340., 513., 688., 173., 348., 525., 704., 177., 356., 537., 720.,
      181., 364., 549., 736., 185., 372., 561., 752., 189., 380., 573., 768.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   9.,   16.,  5.,   12.,  21.,  32.,  9.,   20.,  33.,  48.,
      13.,  28.,  45.,  64.,  17.,  36.,  57.,  80.,  21.,  44.,  69.,  96.,
      25.,  52.,  81.,  112., 29.,  60.,  93.,  128., 33.,  68.,  105., 144.,
      37.,  76.,  117., 160., 41.,  84.,  129., 176., 45.,  92.,  141., 192.,
      49.,  100., 153., 208., 53.,  108., 165., 224., 57.,  116., 177., 240.,
      61.,  124., 189., 256., 65.,  132., 201., 272., 69.,  140., 213., 288.,
      73.,  148., 225., 304., 77.,  156., 237., 320., 81.,  164., 249., 336.,
      85.,  172., 261., 352., 89.,  180., 273., 368., 93.,  188., 285., 384.,
      97.,  196., 297., 400., 101., 204., 309., 416., 105., 212., 321., 432.,
      109., 220., 333., 448., 113., 228., 345., 464., 117., 236., 357., 480.,
      121., 244., 369., 496., 125., 252., 381., 512., 129., 260., 393., 528.,
      133., 268., 405., 544., 137., 276., 417., 560., 141., 284., 429., 576.,
      145., 292., 441., 592., 149., 300., 453., 608., 153., 308., 465., 624.,
      157., 316., 477., 640., 161., 324., 489., 656., 165., 332., 501., 672.,
      169., 340., 513., 688., 173., 348., 525., 704., 177., 356., 537., 720.,
      181., 364., 549., 736., 185., 372., 561., 752., 189., 380., 573., 768.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    6.,    8.,    15.,   18.,   28.,   32.,   5.,    10.,
      18.,   24.,   35.,   42.,   56.,   64.,   9.,    18.,   30.,   40.,
      55.,   66.,   84.,   96.,   13.,   26.,   42.,   56.,   75.,   90.,
      112.,  128.,  17.,   34.,   54.,   72.,   95.,   114.,  140.,  160.,
      21.,   42.,   66.,   88.,   115.,  138.,  168.,  192.,  25.,   50.,
      78.,   104.,  135.,  162.,  196.,  224.,  29.,   58.,   90.,   120.,
      155.,  186.,  224.,  256.,  33.,   66.,   102.,  136.,  175.,  210.,
      252.,  288.,  37.,   74.,   114.,  152.,  195.,  234.,  280.,  320.,
      41.,   82.,   126.,  168.,  215.,  258.,  308.,  352.,  45.,   90.,
      138.,  184.,  235.,  282.,  336.,  384.,  49.,   98.,   150.,  200.,
      255.,  306.,  364.,  416.,  53.,   106.,  162.,  216.,  275.,  330.,
      392.,  448.,  57.,   114.,  174.,  232.,  295.,  354.,  420.,  480.,
      61.,   122.,  186.,  248.,  315.,  378.,  448.,  512.,  65.,   130.,
      198.,  264.,  335.,  402.,  476.,  544.,  69.,   138.,  210.,  280.,
      355.,  426.,  504.,  576.,  73.,   146.,  222.,  296.,  375.,  450.,
      532.,  608.,  77.,   154.,  234.,  312.,  395.,  474.,  560.,  640.,
      81.,   162.,  246.,  328.,  415.,  498.,  588.,  672.,  85.,   170.,
      258.,  344.,  435.,  522.,  616.,  704.,  89.,   178.,  270.,  360.,
      455.,  546.,  644.,  736.,  93.,   186.,  282.,  376.,  475.,  570.,
      672.,  768.,  97.,   194.,  294.,  392.,  495.,  594.,  700.,  800.,
      101.,  202.,  306.,  408.,  515.,  618.,  728.,  832.,  105.,  210.,
      318.,  424.,  535.,  642.,  756.,  864.,  109.,  218.,  330.,  440.,
      555.,  666.,  784.,  896.,  113.,  226.,  342.,  456.,  575.,  690.,
      812.,  928.,  117.,  234.,  354.,  472.,  595.,  714.,  840.,  960.,
      121.,  242.,  366.,  488.,  615.,  738.,  868.,  992.,  125.,  250.,
      378.,  504.,  635.,  762.,  896.,  1024., 129.,  258.,  390.,  520.,
      655.,  786.,  924.,  1056., 133.,  266.,  402.,  536.,  675.,  810.,
      952.,  1088., 137.,  274.,  414.,  552.,  695.,  834.,  980.,  1120.,
      141.,  282.,  426.,  568.,  715.,  858.,  1008., 1152., 145.,  290.,
      438.,  584.,  735.,  882.,  1036., 1184., 149.,  298.,  450.,  600.,
      755.,  906.,  1064., 1216., 153.,  306.,  462.,  616.,  775.,  930.,
      1092., 1248., 157.,  314.,  474.,  632.,  795.,  954.,  1120., 1280.,
      161.,  322.,  486.,  648.,  815.,  978.,  1148., 1312., 165.,  330.,
      498.,  664.,  835.,  1002., 1176., 1344., 169.,  338.,  510.,  680.,
      855.,  1026., 1204., 1376., 173.,  346.,  522.,  696.,  875.,  1050.,
      1232., 1408., 177.,  354.,  534.,  712.,  895.,  1074., 1260., 1440.,
      181.,  362.,  546.,  728.,  915.,  1098., 1288., 1472., 185.,  370.,
      558.,  744.,  935.,  1122., 1316., 1504., 189.,  378.,  570.,  760.,
      955.,  1146., 1344., 1536.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    6.,    8.,    15.,   18.,   28.,   32.,   5.,    10.,
      18.,   24.,   35.,   42.,   56.,   64.,   9.,    18.,   30.,   40.,
      55.,   66.,   84.,   96.,   13.,   26.,   42.,   56.,   75.,   90.,
      112.,  128.,  17.,   34.,   54.,   72.,   95.,   114.,  140.,  160.,
      21.,   42.,   66.,   88.,   115.,  138.,  168.,  192.,  25.,   50.,
      78.,   104.,  135.,  162.,  196.,  224.,  29.,   58.,   90.,   120.,
      155.,  186.,  224.,  256.,  33.,   66.,   102.,  136.,  175.,  210.,
      252.,  288.,  37.,   74.,   114.,  152.,  195.,  234.,  280.,  320.,
      41.,   82.,   126.,  168.,  215.,  258.,  308.,  352.,  45.,   90.,
      138.,  184.,  235.,  282.,  336.,  384.,  49.,   98.,   150.,  200.,
      255.,  306.,  364.,  416.,  53.,   106.,  162.,  216.,  275.,  330.,
      392.,  448.,  57.,   114.,  174.,  232.,  295.,  354.,  420.,  480.,
      61.,   122.,  186.,  248.,  315.,  378.,  448.,  512.,  65.,   130.,
      198.,  264.,  335.,  402.,  476.,  544.,  69.,   138.,  210.,  280.,
      355.,  426.,  504.,  576.,  73.,   146.,  222.,  296.,  375.,  450.,
      532.,  608.,  77.,   154.,  234.,  312.,  395.,  474.,  560.,  640.,
      81.,   162.,  246.,  328.,  415.,  498.,  588.,  672.,  85.,   170.,
      258.,  344.,  435.,  522.,  616.,  704.,  89.,   178.,  270.,  360.,
      455.,  546.,  644.,  736.,  93.,   186.,  282.,  376.,  475.,  570.,
      672.,  768.,  97.,   194.,  294.,  392.,  495.,  594.,  700.,  800.,
      101.,  202.,  306.,  408.,  515.,  618.,  728.,  832.,  105.,  210.,
      318.,  424.,  535.,  642.,  756.,  864.,  109.,  218.,  330.,  440.,
      555.,  666.,  784.,  896.,  113.,  226.,  342.,  456.,  575.,  690.,
      812.,  928.,  117.,  234.,  354.,  472.,  595.,  714.,  840.,  960.,
      121.,  242.,  366.,  488.,  615.,  738.,  868.,  992.,  125.,  250.,
      378.,  504.,  635.,  762.,  896.,  1024., 129.,  258.,  390.,  520.,
      655.,  786.,  924.,  1056., 133.,  266.,  402.,  536.,  675.,  810.,
      952.,  1088., 137.,  274.,  414.,  552.,  695.,  834.,  980.,  1120.,
      141.,  282.,  426.,  568.,  715.,  858.,  1008., 1152., 145.,  290.,
      438.,  584.,  735.,  882.,  1036., 1184., 149.,  298.,  450.,  600.,
      755.,  906.,  1064., 1216., 153.,  306.,  462.,  616.,  775.,  930.,
      1092., 1248., 157.,  314.,  474.,  632.,  795.,  954.,  1120., 1280.,
      161.,  322.,  486.,  648.,  815.,  978.,  1148., 1312., 165.,  330.,
      498.,  664.,  835.,  1002., 1176., 1344., 169.,  338.,  510.,  680.,
      855.,  1026., 1204., 1376., 173.,  346.,  522.,  696.,  875.,  1050.,
      1232., 1408., 177.,  354.,  534.,  712.,  895.,  1074., 1260., 1440.,
      181.,  362.,  546.,  728.,  915.,  1098., 1288., 1472., 185.,  370.,
      558.,  744.,  935.,  1122., 1316., 1504., 189.,  378.,  570.,  760.,
      955.,  1146., 1344., 1536.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    3.,    4.,    10.,   12.,   14.,   16.,   27.,   30.,
      33.,   36.,   52.,   56.,   60.,   64.,   5.,    10.,   15.,   20.,
      30.,   36.,   42.,   48.,   63.,   70.,   77.,   84.,   104.,  112.,
      120.,  128.,  9.,    18.,   27.,   36.,   50.,   60.,   70.,   80.,
      99.,   110.,  121.,  132.,  156.,  168.,  180.,  192.,  13.,   26.,
      39.,   52.,   70.,   84.,   98.,   112.,  135.,  150.,  165.,  180.,
      208.,  224.,  240.,  256.,  17.,   34.,   51.,   68.,   90.,   108.,
      126.,  144.,  171.,  190.,  209.,  228.,  260.,  280.,  300.,  320.,
      21.,   42.,   63.,   84.,   110.,  132.,  154.,  176.,  207.,  230.,
      253.,  276.,  312.,  336.,  360.,  384.,  25.,   50.,   75.,   100.,
      130.,  156.,  182.,  208.,  243.,  270.,  297.,  324.,  364.,  392.,
      420.,  448.,  29.,   58.,   87.,   116.,  150.,  180.,  210.,  240.,
      279.,  310.,  341.,  372.,  416.,  448.,  480.,  512.,  33.,   66.,
      99.,   132.,  170.,  204.,  238.,  272.,  315.,  350.,  385.,  420.,
      468.,  504.,  540.,  576.,  37.,   74.,   111.,  148.,  190.,  228.,
      266.,  304.,  351.,  390.,  429.,  468.,  520.,  560.,  600.,  640.,
      41.,   82.,   123.,  164.,  210.,  252.,  294.,  336.,  387.,  430.,
      473.,  516.,  572.,  616.,  660.,  704.,  45.,   90.,   135.,  180.,
      230.,  276.,  322.,  368.,  423.,  470.,  517.,  564.,  624.,  672.,
      720.,  768.,  49.,   98.,   147.,  196.,  250.,  300.,  350.,  400.,
      459.,  510.,  561.,  612.,  676.,  728.,  780.,  832.,  53.,   106.,
      159.,  212.,  270.,  324.,  378.,  432.,  495.,  550.,  605.,  660.,
      728.,  784.,  840.,  896.,  57.,   114.,  171.,  228.,  290.,  348.,
      406.,  464.,  531.,  590.,  649.,  708.,  780.,  840.,  900.,  960.,
      61.,   122.,  183.,  244.,  310.,  372.,  434.,  496.,  567.,  630.,
      693.,  756.,  832.,  896.,  960.,  1024., 65.,   130.,  195.,  260.,
      330.,  396.,  462.,  528.,  603.,  670.,  737.,  804.,  884.,  952.,
      1020., 1088., 69.,   138.,  207.,  276.,  350.,  420.,  490.,  560.,
      639.,  710.,  781.,  852.,  936.,  1008., 1080., 1152., 73.,   146.,
      219.,  292.,  370.,  444.,  518.,  592.,  675.,  750.,  825.,  900.,
      988.,  1064., 1140., 1216., 77.,   154.,  231.,  308.,  390.,  468.,
      546.,  624.,  711.,  790.,  869.,  948.,  1040., 1120., 1200., 1280.,
      81.,   162.,  243.,  324.,  410.,  492.,  574.,  656.,  747.,  830.,
      913.,  996.,  1092., 1176., 1260., 1344., 85.,   170.,  255.,  340.,
      430.,  516.,  602.,  688.,  783.,  870.,  957.,  1044., 1144., 1232.,
      1320., 1408., 89.,   178.,  267.,  356.,  450.,  540.,  630.,  720.,
      819.,  910.,  1001., 1092., 1196., 1288., 1380., 1472., 93.,   186.,
      279.,  372.,  470.,  564.,  658.,  752.,  855.,  950.,  1045., 1140.,
      1248., 1344., 1440., 1536., 97.,   194.,  291.,  388.,  490.,  588.,
      686.,  784.,  891.,  990.,  1089., 1188., 1300., 1400., 1500., 1600.,
      101.,  202.,  303.,  404.,  510.,  612.,  714.,  816.,  927.,  1030.,
      1133., 1236., 1352., 1456., 1560., 1664., 105.,  210.,  315.,  420.,
      530.,  636.,  742.,  848.,  963.,  1070., 1177., 1284., 1404., 1512.,
      1620., 1728., 109.,  218.,  327.,  436.,  550.,  660.,  770.,  880.,
      999.,  1110., 1221., 1332., 1456., 1568., 1680., 1792., 113.,  226.,
      339.,  452.,  570.,  684.,  798.,  912.,  1035., 1150., 1265., 1380.,
      1508., 1624., 1740., 1856., 117.,  234.,  351.,  468.,  590.,  708.,
      826.,  944.,  1071., 1190., 1309., 1428., 1560., 1680., 1800., 1920.,
      121.,  242.,  363.,  484.,  610.,  732.,  854.,  976.,  1107., 1230.,
      1353., 1476., 1612., 1736., 1860., 1984., 125.,  250.,  375.,  500.,
      630.,  756.,  882.,  1008., 1143., 1270., 1397., 1524., 1664., 1792.,
      1920., 2048., 129.,  258.,  387.,  516.,  650.,  780.,  910.,  1040.,
      1179., 1310., 1441., 1572., 1716., 1848., 1980., 2112., 133.,  266.,
      399.,  532.,  670.,  804.,  938.,  1072., 1215., 1350., 1485., 1620.,
      1768., 1904., 2040., 2176., 137.,  274.,  411.,  548.,  690.,  828.,
      966.,  1104., 1251., 1390., 1529., 1668., 1820., 1960., 2100., 2240.,
      141.,  282.,  423.,  564.,  710.,  852.,  994.,  1136., 1287., 1430.,
      1573., 1716., 1872., 2016., 2160., 2304., 145.,  290.,  435.,  580.,
      730.,  876.,  1022., 1168., 1323., 1470., 1617., 1764., 1924., 2072.,
      2220., 2368., 149.,  298.,  447.,  596.,  750.,  900.,  1050., 1200.,
      1359., 1510., 1661., 1812., 1976., 2128., 2280., 2432., 153.,  306.,
      459.,  612.,  770.,  924.,  1078., 1232., 1395., 1550., 1705., 1860.,
      2028., 2184., 2340., 2496., 157.,  314.,  471.,  628.,  790.,  948.,
      1106., 1264., 1431., 1590., 1749., 1908., 2080., 2240., 2400., 2560.,
      161.,  322.,  483.,  644.,  810.,  972.,  1134., 1296., 1467., 1630.,
      1793., 1956., 2132., 2296., 2460., 2624., 165.,  330.,  495.,  660.,
      830.,  996.,  1162., 1328., 1503., 1670., 1837., 2004., 2184., 2352.,
      2520., 2688., 169.,  338.,  507.,  676.,  850.,  1020., 1190., 1360.,
      1539., 1710., 1881., 2052., 2236., 2408., 2580., 2752., 173.,  346.,
      519.,  692.,  870.,  1044., 1218., 1392., 1575., 1750., 1925., 2100.,
      2288., 2464., 2640., 2816., 177.,  354.,  531.,  708.,  890.,  1068.,
      1246., 1424., 1611., 1790., 1969., 2148., 2340., 2520., 2700., 2880.,
      181.,  362.,  543.,  724.,  910.,  1092., 1274., 1456., 1647., 1830.,
      2013., 2196., 2392., 2576., 2760., 2944., 185.,  370.,  555.,  740.,
      930.,  1116., 1302., 1488., 1683., 1870., 2057., 2244., 2444., 2632.,
      2820., 3008., 189.,  378.,  567.,  756.,  950.,  1140., 1330., 1520.,
      1719., 1910., 2101., 2292., 2496., 2688., 2880., 3072.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    3.,    4.,    10.,   12.,   14.,   16.,   27.,   30.,
      33.,   36.,   52.,   56.,   60.,   64.,   5.,    10.,   15.,   20.,
      30.,   36.,   42.,   48.,   63.,   70.,   77.,   84.,   104.,  112.,
      120.,  128.,  9.,    18.,   27.,   36.,   50.,   60.,   70.,   80.,
      99.,   110.,  121.,  132.,  156.,  168.,  180.,  192.,  13.,   26.,
      39.,   52.,   70.,   84.,   98.,   112.,  135.,  150.,  165.,  180.,
      208.,  224.,  240.,  256.,  17.,   34.,   51.,   68.,   90.,   108.,
      126.,  144.,  171.,  190.,  209.,  228.,  260.,  280.,  300.,  320.,
      21.,   42.,   63.,   84.,   110.,  132.,  154.,  176.,  207.,  230.,
      253.,  276.,  312.,  336.,  360.,  384.,  25.,   50.,   75.,   100.,
      130.,  156.,  182.,  208.,  243.,  270.,  297.,  324.,  364.,  392.,
      420.,  448.,  29.,   58.,   87.,   116.,  150.,  180.,  210.,  240.,
      279.,  310.,  341.,  372.,  416.,  448.,  480.,  512.,  33.,   66.,
      99.,   132.,  170.,  204.,  238.,  272.,  315.,  350.,  385.,  420.,
      468.,  504.,  540.,  576.,  37.,   74.,   111.,  148.,  190.,  228.,
      266.,  304.,  351.,  390.,  429.,  468.,  520.,  560.,  600.,  640.,
      41.,   82.,   123.,  164.,  210.,  252.,  294.,  336.,  387.,  430.,
      473.,  516.,  572.,  616.,  660.,  704.,  45.,   90.,   135.,  180.,
      230.,  276.,  322.,  368.,  423.,  470.,  517.,  564.,  624.,  672.,
      720.,  768.,  49.,   98.,   147.,  196.,  250.,  300.,  350.,  400.,
      459.,  510.,  561.,  612.,  676.,  728.,  780.,  832.,  53.,   106.,
      159.,  212.,  270.,  324.,  378.,  432.,  495.,  550.,  605.,  660.,
      728.,  784.,  840.,  896.,  57.,   114.,  171.,  228.,  290.,  348.,
      406.,  464.,  531.,  590.,  649.,  708.,  780.,  840.,  900.,  960.,
      61.,   122.,  183.,  244.,  310.,  372.,  434.,  496.,  567.,  630.,
      693.,  756.,  832.,  896.,  960.,  1024., 65.,   130.,  195.,  260.,
      330.,  396.,  462.,  528.,  603.,  670.,  737.,  804.,  884.,  952.,
      1020., 1088., 69.,   138.,  207.,  276.,  350.,  420.,  490.,  560.,
      639.,  710.,  781.,  852.,  936.,  1008., 1080., 1152., 73.,   146.,
      219.,  292.,  370.,  444.,  518.,  592.,  675.,  750.,  825.,  900.,
      988.,  1064., 1140., 1216., 77.,   154.,  231.,  308.,  390.,  468.,
      546.,  624.,  711.,  790.,  869.,  948.,  1040., 1120., 1200., 1280.,
      81.,   162.,  243.,  324.,  410.,  492.,  574.,  656.,  747.,  830.,
      913.,  996.,  1092., 1176., 1260., 1344., 85.,   170.,  255.,  340.,
      430.,  516.,  602.,  688.,  783.,  870.,  957.,  1044., 1144., 1232.,
      1320., 1408., 89.,   178.,  267.,  356.,  450.,  540.,  630.,  720.,
      819.,  910.,  1001., 1092., 1196., 1288., 1380., 1472., 93.,   186.,
      279.,  372.,  470.,  564.,  658.,  752.,  855.,  950.,  1045., 1140.,
      1248., 1344., 1440., 1536., 97.,   194.,  291.,  388.,  490.,  588.,
      686.,  784.,  891.,  990.,  1089., 1188., 1300., 1400., 1500., 1600.,
      101.,  202.,  303.,  404.,  510.,  612.,  714.,  816.,  927.,  1030.,
      1133., 1236., 1352., 1456., 1560., 1664., 105.,  210.,  315.,  420.,
      530.,  636.,  742.,  848.,  963.,  1070., 1177., 1284., 1404., 1512.,
      1620., 1728., 109.,  218.,  327.,  436.,  550.,  660.,  770.,  880.,
      999.,  1110., 1221., 1332., 1456., 1568., 1680., 1792., 113.,  226.,
      339.,  452.,  570.,  684.,  798.,  912.,  1035., 1150., 1265., 1380.,
      1508., 1624., 1740., 1856., 117.,  234.,  351.,  468.,  590.,  708.,
      826.,  944.,  1071., 1190., 1309., 1428., 1560., 1680., 1800., 1920.,
      121.,  242.,  363.,  484.,  610.,  732.,  854.,  976.,  1107., 1230.,
      1353., 1476., 1612., 1736., 1860., 1984., 125.,  250.,  375.,  500.,
      630.,  756.,  882.,  1008., 1143., 1270., 1397., 1524., 1664., 1792.,
      1920., 2048., 129.,  258.,  387.,  516.,  650.,  780.,  910.,  1040.,
      1179., 1310., 1441., 1572., 1716., 1848., 1980., 2112., 133.,  266.,
      399.,  532.,  670.,  804.,  938.,  1072., 1215., 1350., 1485., 1620.,
      1768., 1904., 2040., 2176., 137.,  274.,  411.,  548.,  690.,  828.,
      966.,  1104., 1251., 1390., 1529., 1668., 1820., 1960., 2100., 2240.,
      141.,  282.,  423.,  564.,  710.,  852.,  994.,  1136., 1287., 1430.,
      1573., 1716., 1872., 2016., 2160., 2304., 145.,  290.,  435.,  580.,
      730.,  876.,  1022., 1168., 1323., 1470., 1617., 1764., 1924., 2072.,
      2220., 2368., 149.,  298.,  447.,  596.,  750.,  900.,  1050., 1200.,
      1359., 1510., 1661., 1812., 1976., 2128., 2280., 2432., 153.,  306.,
      459.,  612.,  770.,  924.,  1078., 1232., 1395., 1550., 1705., 1860.,
      2028., 2184., 2340., 2496., 157.,  314.,  471.,  628.,  790.,  948.,
      1106., 1264., 1431., 1590., 1749., 1908., 2080., 2240., 2400., 2560.,
      161.,  322.,  483.,  644.,  810.,  972.,  1134., 1296., 1467., 1630.,
      1793., 1956., 2132., 2296., 2460., 2624., 165.,  330.,  495.,  660.,
      830.,  996.,  1162., 1328., 1503., 1670., 1837., 2004., 2184., 2352.,
      2520., 2688., 169.,  338.,  507.,  676.,  850.,  1020., 1190., 1360.,
      1539., 1710., 1881., 2052., 2236., 2408., 2580., 2752., 173.,  346.,
      519.,  692.,  870.,  1044., 1218., 1392., 1575., 1750., 1925., 2100.,
      2288., 2464., 2640., 2816., 177.,  354.,  531.,  708.,  890.,  1068.,
      1246., 1424., 1611., 1790., 1969., 2148., 2340., 2520., 2700., 2880.,
      181.,  362.,  543.,  724.,  910.,  1092., 1274., 1456., 1647., 1830.,
      2013., 2196., 2392., 2576., 2760., 2944., 185.,  370.,  555.,  740.,
      930.,  1116., 1302., 1488., 1683., 1870., 2057., 2244., 2444., 2632.,
      2820., 3008., 189.,  378.,  567.,  756.,  950.,  1140., 1330., 1520.,
      1719., 1910., 2101., 2292., 2496., 2688., 2880., 3072.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, multiplier, padding, max_input_val);
}